-
-
+
+
List<LicenseParagraph?> flatten() =>
+ [for (final entry in this) ...entry, null];Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => UnAppPage(
+ name: Text(packageName),
+ // description: Text(""),
+ slivers: [
+ SliverPadding(
+ padding: const EdgeInsets.all(UnSpaces.M),
+ sliver: LicenseDetailSliver(packageName: packageName),
+ ),
+ ],
+ );final String packageName;Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ final flattenedDetail =
+ context.read<LicenseService>().getLicenseDetail(packageName).flatten();
+
+ return SliverList(
+ delegate: SliverChildBuilderDelegate(
+ childCount: flattenedDetail.length,
+ (context, index) => flattenedDetail[index] != null
+ ? _LicenseBody(flattenedDetail[index]!)
+ : const Padding(
+ padding: EdgeInsets.all(UnSpaces.M),
+ child: Divider(),
+ ),
+ ),
+ );
+}final String packageName;Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => UnAppPage(
+ name: const Text("Acknowledgments"),
+ // description: Text(""),
+ slivers: [
+ LicenseListSliver(onSelectPackage: onSelectPackage),
+ ],
+ );final Function(String packageName) onSelectPackage;Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => SliverPadding(
+ padding: const EdgeInsets.symmetric(vertical: UnSpaces.M),
+ sliver: FutureBuilder<LicenseData>(
+ future: context.read<LicenseService>().licenses,
+ builder: (context, snapshot) => snapshot.hasData
+ ? SliverList(
+ delegate: SliverChildBuilderDelegate(
+ childCount: snapshot.data!.packages.length,
+ (context, index) {
+ final data = snapshot.data!;
+ final package = snapshot.data!.packages[index];
+
+ return item(
+ packageName: package,
+ licenseCount: data.licensesCount(packageName: package),
+ onSelectPackage: onSelectPackage,
+ );
+ },
+ ),
+ )
+ : const SliverFillRemaining(child: CupertinoActivityIndicator()),
+ ),
+ );final Function(String packageName) onSelectPackage;ThemeMode? get themeMode => mapOrNull((_) => _.themeMode);SettingsAppearanceBloc({
required AnalyticService? analyticService,
- required UserService userService,
+ required UserRepository userRepository,
}) : _analyticService = analyticService,
- _userRepository = userService,
+ _userRepository = userRepository,
super(const _Initial()) {
on<_SetThemeMode>(_onSetThemeMode);
- _subscription = userService.streamUser().listen(onSubscriptionData);
+ _subscription = userRepository.streamUser().listen(onSubscriptionData);
}Called whenever an event is added to the Bloc.
+A great spot to add logging/analytics at the individual Bloc level.
Note: super.onEvent should always be called first.
@override
+void onEvent(Event event) {
+ // Always call super.onEvent with the current event
+ super.onEvent(event);
+
+ // Custom onEvent logic goes here
+}
+See also:
+@override
+void onEvent(SettingsAppearanceEvent event) {
+ event.mapOrNull(
+ setThemeMode: (_) => _analyticService?.trackEvent("set_theme_mode"));
+ super.onEvent(event);
+}@JsonKey(ignore: true)
+\$SettingsAppearanceEventCopyWith<SettingsAppearanceEvent> get copyWith =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult map<TResult extends Object?>({
+ required TResult Function(_SetThemeMode value) setThemeMode,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? mapOrNull<TResult extends Object?>({
+ TResult? Function(_SetThemeMode value)? setThemeMode,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeMap<TResult extends Object?>({
+ TResult Function(_SetThemeMode value)? setThemeMode,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeWhen<TResult extends Object?>({
+ TResult Function(ThemeMode themeMode)? setThemeMode,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;ThemeMode get themeMode => throw _privateConstructorUsedError;@optionalTypeArgs
+TResult when<TResult extends Object?>({
+ required TResult Function(ThemeMode themeMode) setThemeMode,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? whenOrNull<TResult extends Object?>({
+ TResult? Function(ThemeMode themeMode)? setThemeMode,
+}) =>
+ throw _privateConstructorUsedError;Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => BlocProvider(
+ create: (context) => SettingsAppearanceBloc(
+ analyticService: context.read(),
+ userRepository: context.read(),
+ ),
+ child: const UnAppPage(
+ name: Text("Appearance"),
+ slivers: [SettingsAppearanceSliver()],
+ ),
+ );Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => SettingsAppearanceBuilder(
+ buildWhen: (previous, current) =>
+ current.themeMode != previous.themeMode,
+ builder: (context, state) => SliverList(
+ delegate: SliverChildListDelegate(
+ SettingsAppearanceView.children(bloc: context.read(), state: state),
+ ),
+ ),
+ );@optionalTypeArgs
+TResult map<TResult extends Object?>(
+ TResult Function(_SettingsAppearanceState value) \$default, {
+ required TResult Function(_Initial value) initial,
+ required TResult Function(_Errored value) errored,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? mapOrNull<TResult extends Object?>(
+ TResult? Function(_SettingsAppearanceState value)? \$default, {
+ TResult? Function(_Initial value)? initial,
+ TResult? Function(_Errored value)? errored,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeMap<TResult extends Object?>(
+ TResult Function(_SettingsAppearanceState value)? \$default, {
+ TResult Function(_Initial value)? initial,
+ TResult Function(_Errored value)? errored,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeWhen<TResult extends Object?>(
+ TResult Function(ThemeMode themeMode)? \$default, {
+ TResult Function()? initial,
+ TResult Function(Object error, StackTrace stackTrace)? errored,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult when<TResult extends Object?>(
+ TResult Function(ThemeMode themeMode) \$default, {
+ required TResult Function() initial,
+ required TResult Function(Object error, StackTrace stackTrace) errored,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? whenOrNull<TResult extends Object?>(
+ TResult? Function(ThemeMode themeMode)? \$default, {
+ TResult? Function()? initial,
+ TResult? Function(Object error, StackTrace stackTrace)? errored,
+}) =>
+ throw _privateConstructorUsedError;Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ return BlocBuilder<SettingsAppearanceBloc, SettingsAppearanceState>(
+ buildWhen: (previous, current) => current.themeMode != previous.themeMode,
+ builder: (context, state) => SliverList(
+ delegate: SliverChildListDelegate(
+ SettingsAppearanceView.children(bloc: context.read(), state: state),
+ ),
+ ),
+ );
+}static List<Widget> children({
+ required SettingsAppearanceBloc bloc,
+ required SettingsAppearanceState state,
+}) =>
+ [
+ ...{
+ "Automatic": ThemeMode.system,
+ "Light": ThemeMode.light,
+ "Dark": ThemeMode.dark,
+ }.entries.map<ListTile>((_) => ListTile(
+ title: Text(_.key),
+ trailing: Visibility(
+ visible: state.themeMode == _.value,
+ child: const Icon(UnSymbols.checkmark),
+ ),
+ onTap: () => bloc.add(
+ SettingsAppearanceEvent.setThemeMode(themeMode: _.value),
+ ),
+ )),
+ ];Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => UnAppPage(
+ name: const Text("Data & Privacy"),
+ slivers: [
+ SettingsDataSliver(
+ onReset: () {
+ // FlutterPlatformAlert.showCustomAlert(
+ // windowTitle: "Erase Your Data",
+ // text:
+ // "Erasing will restore this app to initial state. This action cannot be undone.",
+ // positiveButtonTitle: "Not Now",
+ // negativeButtonTitle: "Erase",
+ // ).then((selection) {
+ // if (selection == CustomButton.negativeButton) {
+ // // repository.reset().then((value) => const ExerciseFlow().go(context));
+ // }
+ // });
+ },
+ )
+ ],
+ );Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => SliverPadding(
+ padding: const EdgeInsets.symmetric(vertical: UnSpaces.M),
+ sliver: SliverList(
+ delegate: SliverChildListDelegate(
+ SettingsDataSliver.children(),
+ ),
+ ));static List<Widget> children() => [
+ ...{
+ "Erase All Content and Settings": () {},
+ }.entries.map(ListItemBuilder.tile),
+ ];Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => UnAppPage(
+ name: const Text("Me"),
+ // description: Text(""),
+ slivers: [
+ SettingsListSliver(
+ onSelectData: onSelectData,
+ onSelectAppearance: onSelectAppearance,
+ onSelectLicense: onSelectLicense,
+ onSelectFeedback: onSelectFeedback,
+ onSelectPrivacy: onSelectPrivacy,
+ onSelectTerms: onSelectTerms,
+ ),
+ if (trailing != null) SliverToBoxAdapter(child: trailing!),
+ ],
+ );final VoidCallback onSelectAppearance;final VoidCallback onSelectData;final VoidCallback onSelectFeedback;final VoidCallback onSelectLicense;final VoidCallback onSelectPrivacy;final VoidCallback onSelectTerms;final Widget? trailing;Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => SliverPadding(
+ padding: const EdgeInsets.symmetric(vertical: UnSpaces.M),
+ sliver: SliverList(
+ delegate: SliverChildListDelegate(
+ children,
+ ),
+ ));List<Widget> get children => [
+ ...{
+ "Data & Privacy": onSelectData,
+ }.entries.map(ListItemBuilder.tile),
+ ListItemBuilder.section("GENERAL"),
+ ...{
+ "Appearance": onSelectAppearance,
+ }.entries.map(ListItemBuilder.tile),
+ ListItemBuilder.section("ABOUT"),
+ ...{
+ "Feedback": onSelectFeedback,
+ "Privacy Policy": onSelectPrivacy,
+ "Terms of Service": onSelectTerms,
+ "Acknowledgments": onSelectLicense,
+ }.entries.map(ListItemBuilder.tile),
+ // const AppInfoView(),
+ ];final VoidCallback onSelectAppearance;final VoidCallback onSelectData;final VoidCallback onSelectFeedback;final VoidCallback onSelectLicense;final VoidCallback onSelectPrivacy;final VoidCallback onSelectTerms;void go(BuildContext context) => context.go(location, extra: this);String get location => GoRouteData.\$location(
+ '/settings/license/\${Uri.encodeComponent(id)}',
+ );void push(BuildContext context) => context.push(location, extra: this);void go(BuildContext context) => context.go(location, extra: this);String get location => GoRouteData.\$location(
+ '/settings/license',
+ );void push(BuildContext context) => context.push(location, extra: this);void go(BuildContext context) => context.go(location, extra: this);String get location => GoRouteData.\$location(
+ '/settings/appearance',
+ );void push(BuildContext context) => context.push(location, extra: this);void go(BuildContext context) => context.go(location, extra: this);String get location => GoRouteData.\$location(
+ '/settings/data',
+ );void push(BuildContext context) => context.push(location, extra: this);void go(BuildContext context) => context.go(location, extra: this);String get location => GoRouteData.\$location(
+ '/settings',
+ );void push(BuildContext context) => context.push(location, extra: this);void go(BuildContext context) => context.go(location, extra: this);String get location => GoRouteData.\$location(
+ '/unpack',
+ );void push(BuildContext context) => context.push(location, extra: this);List<GoRoute> get \$appRoutes => [
+ \$unpackRoutes,
+ \$settingsRoutes,
+ ];GoRoute get \$settingsRoutes => GoRouteData.\$route(
+ path: '/settings',
+ factory: \$SettingsRoutesExtension._fromState,
+ routes: [
+ GoRouteData.\$route(
+ path: 'data',
+ factory: \$SettingsDataRouteExtension._fromState,
+ ),
+ GoRouteData.\$route(
+ path: 'appearance',
+ factory: \$SettingsAppearanceRouteExtension._fromState,
+ ),
+ GoRouteData.\$route(
+ path: 'license',
+ factory: \$LicenseListRouteExtension._fromState,
+ routes: [
+ GoRouteData.\$route(
+ path: ':id',
+ factory: \$LicenseDetailRouteExtension._fromState,
+ ),
+ ],
+ ),
+ ],
+ );GoRoute get \$unpackRoutes => GoRouteData.\$route(
+ path: '/unpack',
+ factory: \$UnpackRoutesExtension._fromState,
+ );AnalyticRouteObserver({
+ required this.analytic,
+ this.nameExtractor = defaultNameExtractor,
+ this.routeFilter = defaultRouteFilter,
+ Function(PlatformException error)? onError,
+}) : _onError = onError;route.
+ route.
+ route.
+ oldRoute with newRoute.
+ routeAware to be informed about changes to route.
+ routeAware.
+ final AnalyticService analytic;static String? defaultNameExtractor(RouteSettings settings) => settings.name;static bool defaultRouteFilter(Route<dynamic>? route) => route is PageRoute;The Navigator popped route.
The route immediately below that one, and thus the newly active
+route, is previousRoute.
@override
+void didPop(Route<dynamic> route, Route<dynamic>? previousRoute) {
+ super.didPop(route, previousRoute);
+ if (previousRoute != null &&
+ routeFilter(previousRoute) &&
+ routeFilter(route)) {
+ _sendScreenView(previousRoute);
+ }
+}The Navigator pushed route.
The route immediately below that one, and thus the previously active
+route, is previousRoute.
@override
+void didPush(Route<dynamic> route, Route<dynamic>? previousRoute) {
+ super.didPush(route, previousRoute);
+ if (routeFilter(route)) {
+ _sendScreenView(route);
+ }
+}The Navigator replaced oldRoute with newRoute.
@override
+void didReplace({Route<dynamic>? newRoute, Route<dynamic>? oldRoute}) {
+ super.didReplace(newRoute: newRoute, oldRoute: oldRoute);
+ if (newRoute != null && routeFilter(newRoute)) {
+ _sendScreenView(newRoute);
+ }
+}final ScreenNameExtractor nameExtractor;final RouteFilter routeFilter;DiagnosticsNode objects describing this node's
+children.
+ Creates the mutable state for this widget at a given location in the tree.
+Subclasses should override this method to return a newly created +instance of their associated State subclass:
+@override
+State<SomeWidget> createState() => _SomeWidgetState();
+The framework can call this method multiple times over the lifetime of
+a StatefulWidget. For example, if the widget is inserted into the tree
+in multiple locations, the framework will create a separate State object
+for each location. Similarly, if the widget is removed from the tree and
+later inserted into the tree again, the framework will call createState
+again to create a fresh State object, simplifying the lifecycle of
+State objects.
@override
+State<App> createState() => _AppState();static Future<MultiProvider> init({
+ Widget Function(BuildContext, Widget?)? builder,
+ required bool isDebug,
+ required String rudderWriteKey,
+ required String rudderDataPlaneUrl,
+}) async {
+ return MultiProvider(
+ builder: builder,
+ providers: [
+ // [Provider] create/update are lazy by default
+ // Provider<UserService>(
+ // create: (_) => const UserService(),
+ // ),
+ Provider<LicenseService>(
+ create: (_) => const LicenseService(),
+ ),
+ // Provider<ExerciseRepository>(
+ // create: (_) => ExerciseRepository(),
+ // ),
+ Provider<AnalyticService>(
+ lazy: false, // Track lifecycle events
+ create: (_) => AnalyticService(
+ rudder: RudderController.instance
+ ..initialize(
+ rudderWriteKey,
+ config: RudderConfigBuilder()
+ .withDataPlaneUrl(rudderDataPlaneUrl)
+ .withFactory(RudderIntegrationFirebaseFlutter())
+ .withDebug(isDebug)
+ .build(),
+ )),
+ ),
+ Provider<InfoService>(
+ create: (_) => InfoService(analytic: _.read()),
+ ),
+ // Provider<MessageService>(
+ // create: (_) => MessageService(),
+ // ),
+ Provider<PerformanceService>(
+ create: (_) =>
+ PerformanceService(performance: FirebasePerformance.instance),
+ ),
+
+ // Provider<FirebaseAppCheck>(
+ // create: (_) => FirebaseAppCheck.instance,
+ // ),
+ // Provider<FirebaseInAppMessaging>(
+ // create: (_) => FirebaseInAppMessaging.instance,
+ // ),
+ // ListenableProvider<FirebaseRemoteConfig>(
+ // create: (_) {
+ // if (remoteConfig != null) {
+ // FirebaseRemoteConfig.instance.setConfigSettings(remoteConfig!);
+ // }
+
+ // return FirebaseRemoteConfig.instance;
+ // },
+ // ),
+ // Provider<GlobalKey<NavigatorState>>.value(
+ // value: AppRouter.defaultNavigator,
+ // ),
+ // if (!kIsWeb)
+ // Provider<RisoShader>.value(
+ // value: await RisoShader.load(),
+ // ),
+ // Provider<Browser>(
+ // create: (context) => Browser(analytics: ),
+ // ),
+
+ Provider<UnDatabase>(
+ create: (_) => UnDatabase(),
+ ),
+ ],
+ child: const App._(),
+ );
+}static GoRouter build({List<NavigatorObserver>? observers}) => GoRouter(
+ observers: observers,
+ debugLogDiagnostics: kDebugMode,
+ navigatorKey: defaultNavigator,
+ initialLocation: defaultLocation,
+ routes: defaultRoutes,
+ );static final String defaultLocation = const SettingsRoutes().location;static final defaultNavigator =
+ GlobalKey<NavigatorState>(debugLabel: 'AppRouter');static final List<RouteBase> defaultRoutes = [AppShell.defaultRoute];DiagnosticsNode objects describing this node's
+children.
+ final Widget child;Creates the mutable state for this widget at a given location in the tree.
+Subclasses should override this method to return a newly created +instance of their associated State subclass:
+@override
+State<SomeWidget> createState() => _SomeWidgetState();
+The framework can call this method multiple times over the lifetime of
+a StatefulWidget. For example, if the widget is inserted into the tree
+in multiple locations, the framework will create a separate State object
+for each location. Similarly, if the widget is removed from the tree and
+later inserted into the tree again, the framework will call createState
+again to create a fresh State object, simplifying the lifecycle of
+State objects.
@override
+State<AppShell> createState() => _AppShellState();static final defaultRoute = ShellRoute(
+ navigatorKey: navigator,
+ pageBuilder: (context, state, child) => UnRootSheetPage(
+ child: MultiProvider(
+ // create: (_) => navigator,
+ providers: [
+ Provider(create: (_) => navigator),
+ // Provider(create: (_) => HomeBloc(navigator: _.read())),
+ ],
+ child: AppShell._(destinations: [
+ _AppShellDestination(
+ path: const UnpackRoutes().location,
+ icon: const Icon(UnSymbols.list),
+ selectedIcon: const Icon(UnSymbols.listFilled),
+ label: 'Unpack',
+ ),
+ _AppShellDestination(
+ path: const SettingsRoutes().location,
+ icon: const Icon(UnSymbols.list),
+ selectedIcon: const Icon(UnSymbols.listFilled),
+ label: 'Timeline',
+ ),
+ ], child: child),
+ ),
+ ),
+ // observers: [
+ // AppRoute.defaultObserver,
+ // ],
+ routes: [
+ // \$sessionFlow,
+ // Workaround for go_router_builder #2672
+ // ..routes.insertAll(0, <GoRoute>[
+ // GoRoute(
+ // path: ":id/edit",
+ // parentNavigatorKey: AppRoute.defaultNavigator,
+ // pageBuilder: (_, state) => SessionEditRoute(state.params["id"]!)
+ // .buildPage(_, state),
+ // ),
+ // ]),
+ // \$exerciseFlow,
+ // ..routes.insertAll(0, <GoRoute>[
+ // GoRoute(
+ // path: ":id/start",
+ // parentNavigatorKey: AppRoute.defaultNavigator,
+ // pageBuilder: (_, state) => ExerciseStartRoute(state.params["id"]!)
+ // .buildPage(_, state),
+ // ),
+ // ]),
+ \$unpackRoutes,
+ \$settingsRoutes,
+ ],
+);static final navigator = GlobalKey<NavigatorState>(debugLabel: 'AppShell');const LicenseDetailRoute(this.id);this route.
+ Creates the Widget for this route.
Subclasses must override one of build, buildPage, or +redirect.
+Corresponds to GoRoute.builder.
+@override
+Widget build(BuildContext context, GoRouterState state) =>
+ LicenseDetailPage(packageName: id);A page builder for this route.
+Subclasses can override this function to provide a custom Page.
+Subclasses must override one of build, buildPage or +redirect.
+Corresponds to GoRoute.pageBuilder.
+By default, returns a Page instance that is ignored, causing a default +Page implementation to be used with the results of build.
+@override
+Page<void> buildPage(BuildContext context, GoRouterState state) =>
+ UnTransitionPage(child: build(context, state), name: name);final String id;static String name = "LicenseDetail";const LicenseListRoute();this route.
+ Creates the Widget for this route.
Subclasses must override one of build, buildPage, or +redirect.
+Corresponds to GoRoute.builder.
+@override
+Widget build(BuildContext context, GoRouterState state) => LicenseListPage(
+ onSelectPackage: (_) => LicenseDetailRoute(_).go(context),
+ );A page builder for this route.
+Subclasses can override this function to provide a custom Page.
+Subclasses must override one of build, buildPage or +redirect.
+Corresponds to GoRoute.pageBuilder.
+By default, returns a Page instance that is ignored, causing a default +Page implementation to be used with the results of build.
+@override
+Page<void> buildPage(BuildContext context, GoRouterState state) =>
+ UnTransitionPage(child: build(context, state), name: name);static String name = "LicenseList";typedef RouteFilter = bool Function(Route<dynamic>? route);typedef ScreenNameExtractor = String? Function(RouteSettings settings);A description for SettingsAppearanceRoute
+const SettingsAppearanceRoute();A description for SettingsAppearanceRoute
+this route.
+ Creates the Widget for this route.
Subclasses must override one of build, buildPage, or +redirect.
+Corresponds to GoRoute.builder.
+@override
+Widget build(context, state) => const SettingsAppearancePage();A page builder for this route.
+Subclasses can override this function to provide a custom Page.
+Subclasses must override one of build, buildPage or +redirect.
+Corresponds to GoRoute.pageBuilder.
+By default, returns a Page instance that is ignored, causing a default +Page implementation to be used with the results of build.
+@override
+Page<void> buildPage(context, state) =>
+ UnTransitionPage(child: build(context, state));static String name = "SettingsAppearance";A description for SettingsDataRoute
+const SettingsDataRoute();A description for SettingsDataRoute
+this route.
+ Creates the Widget for this route.
Subclasses must override one of build, buildPage, or +redirect.
+Corresponds to GoRoute.builder.
+@override
+Widget build(context, state) => const SettingsDataPage();A page builder for this route.
+Subclasses can override this function to provide a custom Page.
+Subclasses must override one of build, buildPage or +redirect.
+Corresponds to GoRoute.pageBuilder.
+By default, returns a Page instance that is ignored, causing a default +Page implementation to be used with the results of build.
+@override
+Page<void> buildPage(context, state) =>
+ UnTransitionPage(child: build(context, state));static String name = "SettingsData";const SettingsListRoute();this route.
+ Creates the Widget for this route.
Subclasses must override one of build, buildPage, or +redirect.
+Corresponds to GoRoute.builder.
+@override
+Widget build(BuildContext context, GoRouterState state) => SettingsListPage(
+ onSelectData: () => const SettingsDataRoute().go(context),
+ onSelectAppearance: () => const SettingsAppearanceRoute().go(context),
+ onSelectLicense: () => const LicenseListRoute().go(context),
+ onSelectFeedback: () => Browser(analytics: context.read())
+ .go(url: "https://unself.app/feedback"),
+ onSelectPrivacy: () => Browser(analytics: context.read())
+ .go(url: "https://unself.app/privacy"),
+ onSelectTerms: () => Browser(analytics: context.read())
+ .go(url: "https://unself.app/terms"),
+ trailing: const AppInfoView(),
+ );A page builder for this route.
+Subclasses can override this function to provide a custom Page.
+Subclasses must override one of build, buildPage or +redirect.
+Corresponds to GoRoute.pageBuilder.
+By default, returns a Page instance that is ignored, causing a default +Page implementation to be used with the results of build.
+@override
+Page<void> buildPage(BuildContext context, GoRouterState state) =>
+ UnTransitionPage(child: build(context, state), name: name);static String name = "SettingsList";const SettingsRoutes();this route.
+ A description for SettingsDataRoute
+const UnpackAssistantRoute();A description for SettingsDataRoute
+this route.
+ Creates the Widget for this route.
Subclasses must override one of build, buildPage, or +redirect.
+Corresponds to GoRoute.builder.
+@override
+Widget build(context, state) => const UnpackAssistantPage();A page builder for this route.
+Subclasses can override this function to provide a custom Page.
+Subclasses must override one of build, buildPage or +redirect.
+Corresponds to GoRoute.pageBuilder.
+By default, returns a Page instance that is ignored, causing a default +Page implementation to be used with the results of build.
+@override
+Page<void> buildPage(context, state) =>
+ UnTransitionPage(child: build(context, state));static String name = "UnpackAssistant";const UnpackRoutes();this route.
+ View of the AppInfoPage.
+Add what it does
+const AppInfoView({super.key});View of the AppInfoPage.
+Add what it does
+DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ final info = context.read<InfoService>();
+ return Padding(
+ padding: const EdgeInsets.symmetric(
+ horizontal: 16.0,
+ vertical: 72.0,
+ ),
+ child: Column(
+ crossAxisAlignment: CrossAxisAlignment.start,
+ children: <Widget>[
+ Text(
+ info.appName,
+ style: Theme.of(context).textTheme.headlineSmall,
+ textAlign: TextAlign.start,
+ ),
+ if (info.version != '')
+ Padding(
+ padding: const EdgeInsets.only(bottom: UnSpaces.M),
+ child: Text(
+ info.version,
+ style: Theme.of(context).textTheme.bodyMedium,
+ textAlign: TextAlign.start,
+ ),
+ ),
+ if (info.buildNumber != '')
+ Text(
+ info.buildNumber,
+ style: Theme.of(context).textTheme.bodySmall,
+ textAlign: TextAlign.start,
+ ),
+ const SizedBox(height: 16),
+ ],
+ ),
+ );
+}View of the Browser.
+Add what it does
+Browser({
+ this.settings,
+ this.analytics,
+});View of the Browser.
+Add what it does
+true if the ChromeSafariBrowser instance is opened, otherwise false.
+ url.
+ url.
+ final AnalyticService? analytics;static ChromeSafariBrowserSettings defaultSettings =
+ ChromeSafariBrowserSettings(
+ shareState: CustomTabsShareState.SHARE_STATE_OFF,
+ barCollapsingEnabled: true,
+ entersReaderIfAvailable: false,
+);void go({
+ required String url,
+ String eventName = 'BrowserView',
+ ChromeSafariBrowserSettings? settings,
+}) {
+ analytics?.trackScreen(eventName);
+ // TODO: Implement for web
+ // kIsWeb ? window.open(url, 'new tab')
+
+ open(
+ url: WebUri(url),
+ settings: settings ?? this.settings ?? defaultSettings,
+ );
+}final ChromeSafariBrowserSettings? settings;\$UnpackSpecTable(this.attachedDatabase, [this._alias]);Tbl and can thus just return their instance.
+ STRICT.
+ LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ Uint8List. Example:
+ alias
+when used in a query.
+ BigInt.
+ enum class T.
+ companion to the real model class, D.
+ enum class T.
+ All columns from this table or view.
+@override
+List<GeneratedColumn> get \$columns =>
+ [id, slug, name, fileSpec, retrieveSpec, modules];The primary key of this table. Can be empty if no custom primary key has +been specified.
+Additional to the Table.primaryKey columns declared by an user, this +also contains auto-increment integers, which are primary key by default.
+@override
+Set<GeneratedColumn> get \$primaryKey => {id};The name of the table in the database. Unlike aliasedName, this can not +be aliased.
+@override
+String get actualTableName => 'unpack_spec';The (potentially aliased) name of this table or view.
+If no alias is active, this is the same as entityName.
+@override
+String get aliasedName => _alias ?? 'unpack_spec';The generated database instance that this view or table is attached to.
+@override
+final GeneratedDatabase attachedDatabase;Creates an alias of this table or view that will write the name alias
+when used in a query.
@override
+\$UnpackSpecTable createAlias(String alias) {
+ return \$UnpackSpecTable(attachedDatabase, alias);
+}@override
+late final GeneratedColumn<String> fileSpec = GeneratedColumn<String>(
+ 'file_spec', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);@override
+late final GeneratedColumn<String> id = GeneratedColumn<String>(
+ 'id', aliasedName, false,
+ type: DriftSqlType.string,
+ requiredDuringInsert: false,
+ clientDefault: () => Slugid.nice().toString());Maps the given row returned by the database into the fitting data class.
+@override
+UnpackSpecData map(Map<String, dynamic> data, {String? tablePrefix}) {
+ final effectivePrefix = tablePrefix != null ? '\$tablePrefix.' : '';
+ return UnpackSpecData(
+ id: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}id'])!,
+ slug: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}slug'])!,
+ name: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}name'])!,
+ fileSpec: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}file_spec'])!,
+ retrieveSpec: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}retrieve_spec'])!,
+ modules: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}modules'])!,
+ );
+}@override
+late final GeneratedColumn<String> modules = GeneratedColumn<String>(
+ 'modules', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);@override
+late final GeneratedColumn<String> name = GeneratedColumn<String>(
+ 'name', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);@override
+late final GeneratedColumn<String> retrieveSpec = GeneratedColumn<String>(
+ 'retrieve_spec', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);@override
+late final GeneratedColumn<String> slug = GeneratedColumn<String>(
+ 'slug', aliasedName, false,
+ type: DriftSqlType.string,
+ requiredDuringInsert: true,
+ defaultConstraints: GeneratedColumn.constraintIsAlways('UNIQUE'));Validates that the given entity can be inserted into this table, meaning +that it respects all constraints (nullability, text length, etc.).
+@override
+VerificationContext validateIntegrity(Insertable<UnpackSpecData> instance,
+ {bool isInserting = false}) {
+ final context = VerificationContext();
+ final data = instance.toColumns(true);
+ if (data.containsKey('id')) {
+ context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
+ }
+ if (data.containsKey('slug')) {
+ context.handle(
+ _slugMeta, slug.isAcceptableOrUnknown(data['slug']!, _slugMeta));
+ } else if (isInserting) {
+ context.missing(_slugMeta);
+ }
+ if (data.containsKey('name')) {
+ context.handle(
+ _nameMeta, name.isAcceptableOrUnknown(data['name']!, _nameMeta));
+ } else if (isInserting) {
+ context.missing(_nameMeta);
+ }
+ if (data.containsKey('file_spec')) {
+ context.handle(_fileSpecMeta,
+ fileSpec.isAcceptableOrUnknown(data['file_spec']!, _fileSpecMeta));
+ } else if (isInserting) {
+ context.missing(_fileSpecMeta);
+ }
+ if (data.containsKey('retrieve_spec')) {
+ context.handle(
+ _retrieveSpecMeta,
+ retrieveSpec.isAcceptableOrUnknown(
+ data['retrieve_spec']!, _retrieveSpecMeta));
+ } else if (isInserting) {
+ context.missing(_retrieveSpecMeta);
+ }
+ if (data.containsKey('modules')) {
+ context.handle(_modulesMeta,
+ modules.isAcceptableOrUnknown(data['modules']!, _modulesMeta));
+ } else if (isInserting) {
+ context.missing(_modulesMeta);
+ }
+ return context;
+}\$UnpackStateTable(this.attachedDatabase, [this._alias]);Tbl and can thus just return their instance.
+ STRICT.
+ LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ Uint8List. Example:
+ alias
+when used in a query.
+ BigInt.
+ enum class T.
+ companion to the real model class, D.
+ enum class T.
+ All columns from this table or view.
+@override
+List<GeneratedColumn> get \$columns =>
+ [id, specId, step, selectedModules, filePath];The primary key of this table. Can be empty if no custom primary key has +been specified.
+Additional to the Table.primaryKey columns declared by an user, this +also contains auto-increment integers, which are primary key by default.
+@override
+Set<GeneratedColumn> get \$primaryKey => {id};The name of the table in the database. Unlike aliasedName, this can not +be aliased.
+@override
+String get actualTableName => 'unpack_state';The (potentially aliased) name of this table or view.
+If no alias is active, this is the same as entityName.
+@override
+String get aliasedName => _alias ?? 'unpack_state';The generated database instance that this view or table is attached to.
+@override
+final GeneratedDatabase attachedDatabase;Creates an alias of this table or view that will write the name alias
+when used in a query.
@override
+\$UnpackStateTable createAlias(String alias) {
+ return \$UnpackStateTable(attachedDatabase, alias);
+}@override
+late final GeneratedColumn<String> filePath = GeneratedColumn<String>(
+ 'file_path', aliasedName, true,
+ type: DriftSqlType.string, requiredDuringInsert: false);@override
+late final GeneratedColumn<String> id = GeneratedColumn<String>(
+ 'id', aliasedName, false,
+ type: DriftSqlType.string,
+ requiredDuringInsert: false,
+ clientDefault: () => Slugid.nice().toString());Maps the given row returned by the database into the fitting data class.
+@override
+UnpackStateData map(Map<String, dynamic> data, {String? tablePrefix}) {
+ final effectivePrefix = tablePrefix != null ? '\$tablePrefix.' : '';
+ return UnpackStateData(
+ id: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}id'])!,
+ specId: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}spec_id'])!,
+ step: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}step'])!,
+ selectedModules: attachedDatabase.typeMapping.read(
+ DriftSqlType.string, data['\${effectivePrefix}selected_modules']),
+ filePath: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}file_path']),
+ );
+}@override
+late final GeneratedColumn<String> selectedModules = GeneratedColumn<String>(
+ 'selected_modules', aliasedName, true,
+ type: DriftSqlType.string, requiredDuringInsert: false);@override
+late final GeneratedColumn<String> specId = GeneratedColumn<String>(
+ 'spec_id', aliasedName, false,
+ type: DriftSqlType.string,
+ requiredDuringInsert: true,
+ defaultConstraints:
+ GeneratedColumn.constraintIsAlways('REFERENCES unpack_spec (id)'));@override
+late final GeneratedColumn<String> step = GeneratedColumn<String>(
+ 'step', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);Validates that the given entity can be inserted into this table, meaning +that it respects all constraints (nullability, text length, etc.).
+@override
+VerificationContext validateIntegrity(Insertable<UnpackStateData> instance,
+ {bool isInserting = false}) {
+ final context = VerificationContext();
+ final data = instance.toColumns(true);
+ if (data.containsKey('id')) {
+ context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
+ }
+ if (data.containsKey('spec_id')) {
+ context.handle(_specIdMeta,
+ specId.isAcceptableOrUnknown(data['spec_id']!, _specIdMeta));
+ } else if (isInserting) {
+ context.missing(_specIdMeta);
+ }
+ if (data.containsKey('step')) {
+ context.handle(
+ _stepMeta, step.isAcceptableOrUnknown(data['step']!, _stepMeta));
+ } else if (isInserting) {
+ context.missing(_stepMeta);
+ }
+ if (data.containsKey('selected_modules')) {
+ context.handle(
+ _selectedModulesMeta,
+ selectedModules.isAcceptableOrUnknown(
+ data['selected_modules']!, _selectedModulesMeta));
+ }
+ if (data.containsKey('file_path')) {
+ context.handle(_filePathMeta,
+ filePath.isAcceptableOrUnknown(data['file_path']!, _filePathMeta));
+ }
+ return context;
+}LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ STRICT.
+ Uint8List. Example:
+ BigInt.
+ enum class T.
+ enum class T.
+ TextColumn get id => text().clientDefault(
+ () => Slugid.nice().toString(), // Compressed UUIDv4
+ )();Override this to specify custom primary keys:
+class IngredientInRecipes extends Table {
+ @override
+ Set<Column> get primaryKey => {recipe, ingredient};
+
+ IntColumn get recipe => integer()();
+ IntColumn get ingredient => integer()();
+
+ IntColumn get amountInGrams => integer().named('amount')();
+}
+The getter must return a set literal using the => syntax so that the
+drift generator can understand the code.
+Also, please note that it's an error to have an
+BuildIntColumn.autoIncrement column and a custom primary key.
+As an auto-incremented IntColumn is recognized by drift to be the
+primary key, doing so will result in an exception thrown at runtime.
@override
+Set<Column> get primaryKey => {id};UnDatabase description
+UnDatabase([QueryExecutor? qe]) : super(qe ?? connect().executor);UnDatabase description
+DatabaseSchemaEntity that are specified in this database.
+ VALUES for an insert statement.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and SelectableUtils.watchSingle which return the item
+directly without wrapping it into a list.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and watchSingle which return the item directly without
+wrapping it into a list.
+ statement on the database.
+ updates parameter so that drift knows which tables are
+affected by your query. All select streams that depend on a table
+specified there will then update their data. For more accurate results,
+you can also set the updateKind parameter to UpdateKind.delete or
+UpdateKind.update. This is optional, but can improve the accuracy of
+query updates, especially when using triggers.
+ INSERT, UPDATE or DELETE statement returning rows.
+ fn after this executor is ready, or directly if it's
+already ready.
+ table by using InsertStatement.insert.
+ tables as updated.
+ updates to the stream query manager.
+ table that doesn't necessarily use all of
+table's columns.
+ action in a transaction, which means that all its queries and
+updates will be called atomically.
+ A list of all DatabaseSchemaEntity that are specified in this database.
This contains allTables, but also advanced entities like triggers.
+@override
+List<DatabaseSchemaEntity> get allSchemaEntities => [unpackSpec, unpackState];A list of tables specified in this database.
+@override
+Iterable<TableInfo<Table, Object?>> get allTables =>
+ allSchemaEntities.whereType<TableInfo<Table, Object?>>();Defines the migration strategy that will determine how to deal with an +increasing schemaVersion. The default value only supports creating the +database by creating all tables known in this database. When you have +changes in your schema, you'll need a custom migration strategy to create +the new tables or change the columns.
+@override
+MigrationStrategy get migration => MigrationStrategy(
+ onCreate: (Migrator m) async {
+ await m.createAll();
+ },
+ onUpgrade: (m, from, to) async {
+ // disable foreign_keys before migrations
+ await customStatement('PRAGMA foreign_keys = OFF');
+ },
+ beforeOpen: (details) async {
+ // foreign key references aren't enabled by default
+ await customStatement('PRAGMA foreign_keys = ON');
+ // collectionDao.
+ },
+ );Specify the schema version of your database. Whenever you change or add +tables, you should bump this field and provide a migration strategy.
+@override
+int get schemaVersion => 1;late final \$UnpackSpecTable unpackSpec = \$UnpackSpecTable(this);late final UnpackSpecDao unpackSpecDao = UnpackSpecDao(this as UnDatabase);late final \$UnpackStateTable unpackState = \$UnpackStateTable(this);late final UnpackStateDao unpackStateDao = UnpackStateDao(this as UnDatabase);STRICT.
+ LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ Uint8List. Example:
+ BigInt.
+ enum class T.
+ enum class T.
+ TextColumn get fileSpec => text()();TextColumn get modules => text()();TextColumn get name => text()();TextColumn get retrieveSpec => text()();TextColumn get slug => text().unique()();UnpackSpecCompanion.insert({
+ this.id = const Value.absent(),
+ required String slug,
+ required String name,
+ required String fileSpec,
+ required String retrieveSpec,
+ required String modules,
+ this.rowid = const Value.absent(),
+}) : slug = Value(slug),
+ name = Value(name),
+ fileSpec = Value(fileSpec),
+ retrieveSpec = Value(retrieveSpec),
+ modules = Value(modules);UnpackSpecCompanion copyWith(
+ {Value<String>? id,
+ Value<String>? slug,
+ Value<String>? name,
+ Value<String>? fileSpec,
+ Value<String>? retrieveSpec,
+ Value<String>? modules,
+ Value<int>? rowid}) {
+ return UnpackSpecCompanion(
+ id: id ?? this.id,
+ slug: slug ?? this.slug,
+ name: name ?? this.name,
+ fileSpec: fileSpec ?? this.fileSpec,
+ retrieveSpec: retrieveSpec ?? this.retrieveSpec,
+ modules: modules ?? this.modules,
+ rowid: rowid ?? this.rowid,
+ );
+}static Insertable<UnpackSpecData> custom({
+ Expression<String>? id,
+ Expression<String>? slug,
+ Expression<String>? name,
+ Expression<String>? fileSpec,
+ Expression<String>? retrieveSpec,
+ Expression<String>? modules,
+ Expression<int>? rowid,
+}) {
+ return RawValuesInsertable({
+ if (id != null) 'id': id,
+ if (slug != null) 'slug': slug,
+ if (name != null) 'name': name,
+ if (fileSpec != null) 'file_spec': fileSpec,
+ if (retrieveSpec != null) 'retrieve_spec': retrieveSpec,
+ if (modules != null) 'modules': modules,
+ if (rowid != null) 'rowid': rowid,
+ });
+}final Value<String> fileSpec;final Value<String> id;final Value<String> modules;final Value<String> name;final Value<String> retrieveSpec;final Value<int> rowid;final Value<String> slug;Converts this object into a map of column names to expressions to insert +or update.
+Note that the keys in the map are the raw column names, they're not +escaped.
+The nullToAbsent can be used on DataClasses to control whether null
+fields should be set to a null constant in sql or absent from the map.
+Other implementations ignore that nullToAbsent, it mainly exists for
+legacy reasons.
@override
+Map<String, Expression> toColumns(bool nullToAbsent) {
+ final map = <String, Expression>{};
+ if (id.present) {
+ map['id'] = Variable<String>(id.value);
+ }
+ if (slug.present) {
+ map['slug'] = Variable<String>(slug.value);
+ }
+ if (name.present) {
+ map['name'] = Variable<String>(name.value);
+ }
+ if (fileSpec.present) {
+ map['file_spec'] = Variable<String>(fileSpec.value);
+ }
+ if (retrieveSpec.present) {
+ map['retrieve_spec'] = Variable<String>(retrieveSpec.value);
+ }
+ if (modules.present) {
+ map['modules'] = Variable<String>(modules.value);
+ }
+ if (rowid.present) {
+ map['rowid'] = Variable<int>(rowid.value);
+ }
+ return map;
+}A string representation of this object.
+Some classes have a default textual representation,
+often paired with a static parse function (like int.parse).
+These classes will provide the textual representation as
+their string representation.
Other classes have no meaningful textual representation
+that a program will care about.
+Such classes will typically override toString to provide
+useful information when inspecting the object,
+mainly for debugging or logging.
@override
+String toString() {
+ return (StringBuffer('UnpackSpecCompanion(')
+ ..write('id: \$id, ')
+ ..write('slug: \$slug, ')
+ ..write('name: \$name, ')
+ ..write('fileSpec: \$fileSpec, ')
+ ..write('retrieveSpec: \$retrieveSpec, ')
+ ..write('modules: \$modules, ')
+ ..write('rowid: \$rowid')
+ ..write(')'))
+ .toString();
+}UnpackSpecDao(super.attachedDatabase);VALUES for an insert statement.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and SelectableUtils.watchSingle which return the item
+directly without wrapping it into a list.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and watchSingle which return the item directly without
+wrapping it into a list.
+ statement on the database.
+ updates parameter so that drift knows which tables are
+affected by your query. All select streams that depend on a table
+specified there will then update their data. For more accurate results,
+you can also set the updateKind parameter to UpdateKind.delete or
+UpdateKind.update. This is optional, but can improve the accuracy of
+query updates, especially when using triggers.
+ INSERT, UPDATE or DELETE statement returning rows.
+ fn after this executor is ready, or directly if it's
+already ready.
+ table by using InsertStatement.insert.
+ tables as updated.
+ updates to the stream query manager.
+ table that doesn't necessarily use all of
+table's columns.
+ action in a transaction, which means that all its queries and
+updates will be called atomically.
+ Future<int> get count {
+ final countExp = unpackSpec.id.count();
+ final q = selectOnly(unpackSpec)..addColumns([countExp]);
+
+ return q.map((row) => row.read(countExp)).getSingle().then((_) => _!);
+}Future<UnpackSpecData> get(String id) {
+ final q = select(unpackSpec)..where((t) => t.id.equals(id));
+ return q.getSingle();
+}Future<List<UnpackSpecData>> getAll() => select(unpackSpec).get();Future<bool> get isEmpty => count.then((value) => value == 0);Future<UnpackSpecData> put(Insertable<UnpackSpecData> entity) =>
+ into(unpackSpec)
+ .insertReturning(entity, mode: InsertMode.insertOrReplace);Future<void> putAll(Iterable<Insertable<UnpackSpecData>> entities) =>
+ batch((batch) => batch.insertAll(unpackSpec, entities,
+ mode: InsertMode.insertOrReplace));\$UnpackSpecTable get unpackSpec => attachedDatabase.unpackSpec;Stream<List<UnpackSpecData>> watchAll() => select(unpackSpec).watch();const UnpackSpecData(
+ {required this.id,
+ required this.slug,
+ required this.name,
+ required this.fileSpec,
+ required this.retrieveSpec,
+ required this.modules});json. The serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
+ serializer can be
+used to configure how individual values will be encoded. By default,
+DriftRuntimeOptions.defaultSerializer will be used. See
+ValueSerializer.defaults for details.
+ UnpackSpecData copyWith(
+ {String? id,
+ String? slug,
+ String? name,
+ String? fileSpec,
+ String? retrieveSpec,
+ String? modules}) =>
+ UnpackSpecData(
+ id: id ?? this.id,
+ slug: slug ?? this.slug,
+ name: name ?? this.name,
+ fileSpec: fileSpec ?? this.fileSpec,
+ retrieveSpec: retrieveSpec ?? this.retrieveSpec,
+ modules: modules ?? this.modules,
+ );final String fileSpec;The hash code for this object.
+A hash code is a single integer which represents the state of the object +that affects operator == comparisons.
+All objects have hash codes. +The default hash code implemented by Object +represents only the identity of the object, +the same way as the default operator == implementation only considers objects +equal if they are identical (see identityHashCode).
+If operator == is overridden to use the object state instead, +the hash code must also be changed to represent that state, +otherwise the object cannot be used in hash based data structures +like the default Set and Map implementations.
+Hash codes must be the same for objects that are equal to each other +according to operator ==. +The hash code of an object should only change if the object changes +in a way that affects equality. +There are no further requirements for the hash codes. +They need not be consistent between executions of the same program +and there are no distribution guarantees.
+Objects that are not equal are allowed to have the same hash code. +It is even technically allowed that all instances have the same hash code, +but if clashes happen too often, +it may reduce the efficiency of hash-based data structures +like HashSet or HashMap.
+If a subclass overrides hashCode, it should override the +operator == operator as well to maintain consistency.
+@override
+int get hashCode =>
+ Object.hash(id, slug, name, fileSpec, retrieveSpec, modules);final String id;final String modules;final String name;The equality operator.
+The default behavior for all Objects is to return true if and
+only if this object and other are the same object.
Override this method to specify a different equality relation on +a class. The overriding method must still be an equivalence relation. +That is, it must be:
+Total: It must return a boolean for all arguments. It should never throw.
+Reflexive: For all objects o, o == o must be true.
Symmetric: For all objects o1 and o2, o1 == o2 and o2 == o1 must
+either both be true, or both be false.
Transitive: For all objects o1, o2, and o3, if o1 == o2 and
+o2 == o3 are true, then o1 == o3 must be true.
The method should also be consistent over time, +so whether two objects are equal should only change +if at least one of the objects was modified.
+If a subclass overrides the equality operator, it should override +the hashCode method as well to maintain consistency.
+@override
+bool operator ==(Object other) =>
+ identical(this, other) ||
+ (other is UnpackSpecData &&
+ other.id == this.id &&
+ other.slug == this.slug &&
+ other.name == this.name &&
+ other.fileSpec == this.fileSpec &&
+ other.retrieveSpec == this.retrieveSpec &&
+ other.modules == this.modules);final String retrieveSpec;final String slug;Converts this object into a map of column names to expressions to insert +or update.
+Note that the keys in the map are the raw column names, they're not +escaped.
+The nullToAbsent can be used on DataClasses to control whether null
+fields should be set to a null constant in sql or absent from the map.
+Other implementations ignore that nullToAbsent, it mainly exists for
+legacy reasons.
@override
+Map<String, Expression> toColumns(bool nullToAbsent) {
+ final map = <String, Expression>{};
+ map['id'] = Variable<String>(id);
+ map['slug'] = Variable<String>(slug);
+ map['name'] = Variable<String>(name);
+ map['file_spec'] = Variable<String>(fileSpec);
+ map['retrieve_spec'] = Variable<String>(retrieveSpec);
+ map['modules'] = Variable<String>(modules);
+ return map;
+}UnpackSpecCompanion toCompanion(bool nullToAbsent) {
+ return UnpackSpecCompanion(
+ id: Value(id),
+ slug: Value(slug),
+ name: Value(name),
+ fileSpec: Value(fileSpec),
+ retrieveSpec: Value(retrieveSpec),
+ modules: Value(modules),
+ );
+}Converts this object into a representation that can be encoded with
+json. The serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
@override
+Map<String, dynamic> toJson({ValueSerializer? serializer}) {
+ serializer ??= driftRuntimeOptions.defaultSerializer;
+ return <String, dynamic>{
+ 'id': serializer.toJson<String>(id),
+ 'slug': serializer.toJson<String>(slug),
+ 'name': serializer.toJson<String>(name),
+ 'fileSpec': serializer.toJson<String>(fileSpec),
+ 'retrieveSpec': serializer.toJson<String>(retrieveSpec),
+ 'modules': serializer.toJson<String>(modules),
+ };
+}A string representation of this object.
+Some classes have a default textual representation,
+often paired with a static parse function (like int.parse).
+These classes will provide the textual representation as
+their string representation.
Other classes have no meaningful textual representation
+that a program will care about.
+Such classes will typically override toString to provide
+useful information when inspecting the object,
+mainly for debugging or logging.
@override
+String toString() {
+ return (StringBuffer('UnpackSpecData(')
+ ..write('id: \$id, ')
+ ..write('slug: \$slug, ')
+ ..write('name: \$name, ')
+ ..write('fileSpec: \$fileSpec, ')
+ ..write('retrieveSpec: \$retrieveSpec, ')
+ ..write('modules: \$modules')
+ ..write(')'))
+ .toString();
+}STRICT.
+ LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ Uint8List. Example:
+ BigInt.
+ enum class T.
+ enum class T.
+ TextColumn get filePath => text().nullable()();TextColumn get selectedModules => text().nullable()();TextColumn get specId => text().references(UnpackSpec, #id)();TextColumn get step => text()();UnpackStateCompanion.insert({
+ this.id = const Value.absent(),
+ required String specId,
+ required String step,
+ this.selectedModules = const Value.absent(),
+ this.filePath = const Value.absent(),
+ this.rowid = const Value.absent(),
+}) : specId = Value(specId),
+ step = Value(step);UnpackStateCompanion copyWith(
+ {Value<String>? id,
+ Value<String>? specId,
+ Value<String>? step,
+ Value<String?>? selectedModules,
+ Value<String?>? filePath,
+ Value<int>? rowid}) {
+ return UnpackStateCompanion(
+ id: id ?? this.id,
+ specId: specId ?? this.specId,
+ step: step ?? this.step,
+ selectedModules: selectedModules ?? this.selectedModules,
+ filePath: filePath ?? this.filePath,
+ rowid: rowid ?? this.rowid,
+ );
+}static Insertable<UnpackStateData> custom({
+ Expression<String>? id,
+ Expression<String>? specId,
+ Expression<String>? step,
+ Expression<String>? selectedModules,
+ Expression<String>? filePath,
+ Expression<int>? rowid,
+}) {
+ return RawValuesInsertable({
+ if (id != null) 'id': id,
+ if (specId != null) 'spec_id': specId,
+ if (step != null) 'step': step,
+ if (selectedModules != null) 'selected_modules': selectedModules,
+ if (filePath != null) 'file_path': filePath,
+ if (rowid != null) 'rowid': rowid,
+ });
+}final Value<String?> filePath;final Value<String> id;final Value<int> rowid;final Value<String?> selectedModules;final Value<String> specId;final Value<String> step;Converts this object into a map of column names to expressions to insert +or update.
+Note that the keys in the map are the raw column names, they're not +escaped.
+The nullToAbsent can be used on DataClasses to control whether null
+fields should be set to a null constant in sql or absent from the map.
+Other implementations ignore that nullToAbsent, it mainly exists for
+legacy reasons.
@override
+Map<String, Expression> toColumns(bool nullToAbsent) {
+ final map = <String, Expression>{};
+ if (id.present) {
+ map['id'] = Variable<String>(id.value);
+ }
+ if (specId.present) {
+ map['spec_id'] = Variable<String>(specId.value);
+ }
+ if (step.present) {
+ map['step'] = Variable<String>(step.value);
+ }
+ if (selectedModules.present) {
+ map['selected_modules'] = Variable<String>(selectedModules.value);
+ }
+ if (filePath.present) {
+ map['file_path'] = Variable<String>(filePath.value);
+ }
+ if (rowid.present) {
+ map['rowid'] = Variable<int>(rowid.value);
+ }
+ return map;
+}A string representation of this object.
+Some classes have a default textual representation,
+often paired with a static parse function (like int.parse).
+These classes will provide the textual representation as
+their string representation.
Other classes have no meaningful textual representation
+that a program will care about.
+Such classes will typically override toString to provide
+useful information when inspecting the object,
+mainly for debugging or logging.
@override
+String toString() {
+ return (StringBuffer('UnpackStateCompanion(')
+ ..write('id: \$id, ')
+ ..write('specId: \$specId, ')
+ ..write('step: \$step, ')
+ ..write('selectedModules: \$selectedModules, ')
+ ..write('filePath: \$filePath, ')
+ ..write('rowid: \$rowid')
+ ..write(')'))
+ .toString();
+}UnpackStateDao(super.attachedDatabase);VALUES for an insert statement.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and SelectableUtils.watchSingle which return the item
+directly without wrapping it into a list.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and watchSingle which return the item directly without
+wrapping it into a list.
+ statement on the database.
+ updates parameter so that drift knows which tables are
+affected by your query. All select streams that depend on a table
+specified there will then update their data. For more accurate results,
+you can also set the updateKind parameter to UpdateKind.delete or
+UpdateKind.update. This is optional, but can improve the accuracy of
+query updates, especially when using triggers.
+ INSERT, UPDATE or DELETE statement returning rows.
+ fn after this executor is ready, or directly if it's
+already ready.
+ table by using InsertStatement.insert.
+ tables as updated.
+ updates to the stream query manager.
+ table that doesn't necessarily use all of
+table's columns.
+ action in a transaction, which means that all its queries and
+updates will be called atomically.
+ Future<int> get count {
+ final countExp = unpackState.id.count();
+ final q = selectOnly(unpackState)..addColumns([countExp]);
+
+ return q.map((row) => row.read(countExp)).getSingle().then((_) => _!);
+}Future<UnpackStateData> get(String id) =>
+ (select(unpackState)..where((t) => t.id.equals(id))).getSingle();Future<List<UnpackStateData>> getAll() => select(unpackState).get();Future<bool> get isEmpty => count.then((value) => value == 0);Future<UnpackStateData> put(Insertable<UnpackStateData> entity) =>
+ into(unpackState)
+ .insertReturning(entity, mode: InsertMode.insertOrReplace);\$UnpackSpecTable get unpackSpec => attachedDatabase.unpackSpec;\$UnpackStateTable get unpackState => attachedDatabase.unpackState;Stream<List<UnpackStateData>> watchAll() => select(unpackState).watch();const UnpackStateData(
+ {required this.id,
+ required this.specId,
+ required this.step,
+ this.selectedModules,
+ this.filePath});json. The serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
+ serializer can be
+used to configure how individual values will be encoded. By default,
+DriftRuntimeOptions.defaultSerializer will be used. See
+ValueSerializer.defaults for details.
+ UnpackStateData copyWith(
+ {String? id,
+ String? specId,
+ String? step,
+ Value<String?> selectedModules = const Value.absent(),
+ Value<String?> filePath = const Value.absent()}) =>
+ UnpackStateData(
+ id: id ?? this.id,
+ specId: specId ?? this.specId,
+ step: step ?? this.step,
+ selectedModules: selectedModules.present
+ ? selectedModules.value
+ : this.selectedModules,
+ filePath: filePath.present ? filePath.value : this.filePath,
+ );final String? filePath;The hash code for this object.
+A hash code is a single integer which represents the state of the object +that affects operator == comparisons.
+All objects have hash codes. +The default hash code implemented by Object +represents only the identity of the object, +the same way as the default operator == implementation only considers objects +equal if they are identical (see identityHashCode).
+If operator == is overridden to use the object state instead, +the hash code must also be changed to represent that state, +otherwise the object cannot be used in hash based data structures +like the default Set and Map implementations.
+Hash codes must be the same for objects that are equal to each other +according to operator ==. +The hash code of an object should only change if the object changes +in a way that affects equality. +There are no further requirements for the hash codes. +They need not be consistent between executions of the same program +and there are no distribution guarantees.
+Objects that are not equal are allowed to have the same hash code. +It is even technically allowed that all instances have the same hash code, +but if clashes happen too often, +it may reduce the efficiency of hash-based data structures +like HashSet or HashMap.
+If a subclass overrides hashCode, it should override the +operator == operator as well to maintain consistency.
+@override
+int get hashCode => Object.hash(id, specId, step, selectedModules, filePath);final String id;The equality operator.
+The default behavior for all Objects is to return true if and
+only if this object and other are the same object.
Override this method to specify a different equality relation on +a class. The overriding method must still be an equivalence relation. +That is, it must be:
+Total: It must return a boolean for all arguments. It should never throw.
+Reflexive: For all objects o, o == o must be true.
Symmetric: For all objects o1 and o2, o1 == o2 and o2 == o1 must
+either both be true, or both be false.
Transitive: For all objects o1, o2, and o3, if o1 == o2 and
+o2 == o3 are true, then o1 == o3 must be true.
The method should also be consistent over time, +so whether two objects are equal should only change +if at least one of the objects was modified.
+If a subclass overrides the equality operator, it should override +the hashCode method as well to maintain consistency.
+@override
+bool operator ==(Object other) =>
+ identical(this, other) ||
+ (other is UnpackStateData &&
+ other.id == this.id &&
+ other.specId == this.specId &&
+ other.step == this.step &&
+ other.selectedModules == this.selectedModules &&
+ other.filePath == this.filePath);final String? selectedModules;final String specId;final String step;Converts this object into a map of column names to expressions to insert +or update.
+Note that the keys in the map are the raw column names, they're not +escaped.
+The nullToAbsent can be used on DataClasses to control whether null
+fields should be set to a null constant in sql or absent from the map.
+Other implementations ignore that nullToAbsent, it mainly exists for
+legacy reasons.
@override
+Map<String, Expression> toColumns(bool nullToAbsent) {
+ final map = <String, Expression>{};
+ map['id'] = Variable<String>(id);
+ map['spec_id'] = Variable<String>(specId);
+ map['step'] = Variable<String>(step);
+ if (!nullToAbsent || selectedModules != null) {
+ map['selected_modules'] = Variable<String>(selectedModules);
+ }
+ if (!nullToAbsent || filePath != null) {
+ map['file_path'] = Variable<String>(filePath);
+ }
+ return map;
+}UnpackStateCompanion toCompanion(bool nullToAbsent) {
+ return UnpackStateCompanion(
+ id: Value(id),
+ specId: Value(specId),
+ step: Value(step),
+ selectedModules: selectedModules == null && nullToAbsent
+ ? const Value.absent()
+ : Value(selectedModules),
+ filePath: filePath == null && nullToAbsent
+ ? const Value.absent()
+ : Value(filePath),
+ );
+}Converts this object into a representation that can be encoded with
+json. The serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
@override
+Map<String, dynamic> toJson({ValueSerializer? serializer}) {
+ serializer ??= driftRuntimeOptions.defaultSerializer;
+ return <String, dynamic>{
+ 'id': serializer.toJson<String>(id),
+ 'specId': serializer.toJson<String>(specId),
+ 'step': serializer.toJson<String>(step),
+ 'selectedModules': serializer.toJson<String?>(selectedModules),
+ 'filePath': serializer.toJson<String?>(filePath),
+ };
+}A string representation of this object.
+Some classes have a default textual representation,
+often paired with a static parse function (like int.parse).
+These classes will provide the textual representation as
+their string representation.
Other classes have no meaningful textual representation
+that a program will care about.
+Such classes will typically override toString to provide
+useful information when inspecting the object,
+mainly for debugging or logging.
@override
+String toString() {
+ return (StringBuffer('UnpackStateData(')
+ ..write('id: \$id, ')
+ ..write('specId: \$specId, ')
+ ..write('step: \$step, ')
+ ..write('selectedModules: \$selectedModules, ')
+ ..write('filePath: \$filePath')
+ ..write(')'))
+ .toString();
+}== padding.
+T to indicate presence or absence
+explicitly.
+Maps a column from the database back to Dart.
+@override
+List<T> fromSql(String fromDb) => List<T>.from(jsonDecode(fromDb) ?? []);Map a value from an object in Dart into something that will be understood +by the database.
+@override
+String toSql(List<T> value) => jsonEncode(value);Maps a column from the database back to Dart.
+@override
+Map<String, T> fromSql(String fromDb) =>
+ Map<String, T>.from(jsonDecode(fromDb) ?? {});Map a value from an object in Dart into something that will be understood +by the database.
+@override
+String toSql(Map<String, T> value) => jsonEncode(value);DatabaseConnection connect() {
+ throw UnsupportedError(
+ 'No suitable database implementation was found on this platform.');
+}static final FilePicker instance = throw UnsupportedError(
+ 'Unsupported platform: Only supported on web and native');XPlatformFile({
+ super.path,
+ required super.name,
+ required super.size,
+ super.bytes,
+ super.readStream,
+ super.identifier,
+ required String objectUrl,
+}) : _unsafePath = objectUrl;null on all other platforms since those are all already referencing the original file content.
+ 0 if the file size could not be
+determined.
+ XFile get xFile =>
+ kIsWeb ? XFile((this as XPlatformFile)._unsafePath) : XFile(path!);static FutureOr<Archive> decodeXFile(
+ XFile xFile, {
+ bool verify = false,
+ String? password,
+}) =>
+ throw StateError('Stub implementation');''
+ An interface for LicenseService
+void addLicense(LicenseEntry entry) {
+ for (final String package in entry.packages) {
+ _addPackage(package);
+
+ packageLicenseBindings[package]!.add(licenses.length);
+ }
+ licenses.add(entry);
+}String? firstPackage;final List<LicenseEntry> licenses = <LicenseEntry>[];final Map<String, List<int>> packageLicenseBindings = <String, List<int>>{};final List<String> packages = <String>[];void sortPackages([int Function(String a, String b)? compare]) {
+ packages.sort(compare ??
+ (String a, String b) {
+ if (a == firstPackage) {
+ return -1;
+ }
+ if (b == firstPackage) {
+ return 1;
+ }
+
+ return a.toLowerCase().compareTo(b.toLowerCase());
+ });
+}LicenseService description
+const LicenseService();LicenseService description
+List<List<LicenseParagraph>> getLicenseDetail(String packageName) {
+ if (_licenses == null) throw Exception('LicenseData is not loaded yet.');
+
+ // if (_licensesDetail.containsKey(packageName)) {
+ // return _licensesDetail[packageName]!;
+ // }
+
+ final List<int> bindings =
+ _licenses!.packageLicenseBindings[packageName] ?? [];
+ final List<LicenseEntry> licenseEntries =
+ bindings.map((int i) => _licenses!.licenses[i]).toList(growable: false);
+
+ List<List<LicenseParagraph>> licenseDetail = List.empty(growable: true);
+
+ for (final LicenseEntry license in licenseEntries) {
+ licenseDetail.add(
+ license.paragraphs.toList(),
+ );
+ }
+
+ // _licensesDetail[packageName] = licenseDetail;
+
+ return licenseDetail;
+}Future<LicenseData> get licenses async =>
+ (_licenses ??= await LicenseRegistry.licenses
+ .fold<LicenseData>(
+ LicenseData(),
+ (LicenseData prev, LicenseEntry license) =>
+ prev..addLicense(license),
+ )
+ .then((LicenseData licenseData) => licenseData..sortPackages()))!;typedef AccumulatorCallback = void Function(
+ String name,
+ String key,
+ dynamic entity,
+);const factory CustomModule(
+ {required final String id,
+ required final String name,
+ required final Pattern fileMatcher,
+ required final ExtractSpec extract,
+ required final TransformSpec transform,
+ required final LoadSpec load}) = _\$CustomModule;@override
+@JsonKey(ignore: true)
+_\$\$CustomModuleCopyWith<_\$CustomModule> get copyWith =>
+ throw _privateConstructorUsedError;ExtractSpec get extract;@override
+Pattern get fileMatcher;@override
+String get id;@override
+LoadSpec get load;@override
+String get name;TransformSpec get transform;typedef DoCallback = dynamic Function(dynamic json, JsonRef schema);const factory Edge({
+ String? id,
+ required String specSlug,
+ String? sourceId,
+ String? targetId,
+ @JsonEmptyMap() @Default({}) Map<String, dynamic> properties,
+}) = _Edge;@JsonKey(ignore: true)
+\$EdgeCopyWith<Edge> get copyWith => throw _privateConstructorUsedError;String? get id => throw _privateConstructorUsedError;@JsonEmptyMap()
+Map<String, dynamic> get properties => throw _privateConstructorUsedError;String? get sourceId => throw _privateConstructorUsedError;String get specSlug => throw _privateConstructorUsedError;String? get targetId => throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;@override
+String get type => specSlug;const factory EdgeSpec({
+ String? id,
+ String? slugged,
+ required String name,
+ required String type,
+ required String sourceNodeSpecId,
+ required String targetNodeSpecId,
+ required List<PropSpec> propSpecs,
+}) = _EdgeSpec;@JsonKey(ignore: true)
+\$EdgeSpecCopyWith<EdgeSpec> get copyWith =>
+ throw _privateConstructorUsedError;String? get id => throw _privateConstructorUsedError;String get name => throw _privateConstructorUsedError;List<PropSpec> get propSpecs => throw _privateConstructorUsedError;String get slug => slugged ?? slugify(name, delimiter: '_');String? get slugged => throw _privateConstructorUsedError;String get sourceNodeSpecId => throw _privateConstructorUsedError;String get targetNodeSpecId => throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;String get type => throw _privateConstructorUsedError;const factory Entity(final String name,
+ {final Map<String, IJsonSchema> definition,
+ final String key,
+ @JsonEmptyMap() final Map<String, dynamic> extra}) = _\$Entity;@override
+@JsonKey(ignore: true)
+_\$\$EntityCopyWith<_\$Entity> get copyWith =>
+ throw _privateConstructorUsedError;@override
+Map<String, IJsonSchema> get definition;extra is a map of additional properties.
+@override
+
+/// [extra] is a map of additional properties.
+@JsonEmptyMap()
+Map<String, dynamic> get extra;String get key;@override
+String get name;factory ExtractSpec.fromJson(Map<String, dynamic> json) =>
+ _\$ExtractSpecFromJson(json);@optionalTypeArgs
+TResult map<TResult extends Object?>({
+ required TResult Function(JsonExtractSpec value) json,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? mapOrNull<TResult extends Object?>({
+ TResult? Function(JsonExtractSpec value)? json,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeMap<TResult extends Object?>({
+ TResult Function(JsonExtractSpec value)? json,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeWhen<TResult extends Object?>({
+ TResult Function()? json,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;@optionalTypeArgs
+TResult when<TResult extends Object?>({
+ required TResult Function() json,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? whenOrNull<TResult extends Object?>({
+ TResult? Function()? json,
+}) =>
+ throw _privateConstructorUsedError;factory FileSpec.fromJson(Map<String, dynamic> json) =>
+ _\$FileSpecFromJson(json);@optionalTypeArgs
+TResult map<TResult extends Object?>({
+ required TResult Function(ZipFileSpec value) zip,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? mapOrNull<TResult extends Object?>({
+ TResult? Function(ZipFileSpec value)? zip,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeMap<TResult extends Object?>({
+ TResult Function(ZipFileSpec value)? zip,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeWhen<TResult extends Object?>({
+ TResult Function()? zip,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;@optionalTypeArgs
+TResult when<TResult extends Object?>({
+ required TResult Function() zip,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? whenOrNull<TResult extends Object?>({
+ TResult? Function()? zip,
+}) =>
+ throw _privateConstructorUsedError;const factory Flat(final String name,
+ {final Map<String, IJsonSchema> definition,
+ final String key,
+ final List<String> entityPath,
+ final List<List<String>> includePath,
+ final bool addMissingKeys,
+ @JsonEmptyMap() final Map<String, dynamic> extra}) = _\$Flat;bool get addMissingKeys;@override
+@JsonKey(ignore: true)
+_\$\$FlatCopyWith<_\$Flat> get copyWith => throw _privateConstructorUsedError;@override
+Map<String, IJsonSchema> get definition;List<String> get entityPath;extra is a map of additional properties.
+@override
+
+/// [extra] is a map of additional properties.
+@JsonEmptyMap()
+Map<String, dynamic> get extra;List<List<String>> get includePath;String get key;@override
+String get name;String? get id;Map<String, dynamic>? get properties;String get type;const IJsonSchema();static dynamic structFromJson(dynamic json) {
+ if (json is Map<String, dynamic> &&
+ json['runtimeType'] is String &&
+ json['runtimeType'].startsWith('Json')) {
+ return IJsonSchema.fromJson(json);
+ }
+
+ if (json is Map) {
+ return json.map((k, v) => MapEntry(k, structFromJson(v)));
+ }
+
+ if (json is List) {
+ return json.map((value) => structFromJson(value)).toList();
+ }
+ return json;
+}Map<String, dynamic> toJson();const IJsonSchemaRef();String? get id;List<String> get labels;Map<String, dynamic>? get properties;factory JsonExtractSpec.fromJson(Map<String, dynamic> json) =
+ _\$JsonExtractSpec.fromJson;factory JsonModule.fromJson(Map<String, dynamic> json) =
+ _\$JsonModule.fromJson;@override
+@JsonKey(ignore: true)
+_\$\$JsonModuleCopyWith<_\$JsonModule> get copyWith =>
+ throw _privateConstructorUsedError;@override
+Pattern get fileMatcher;@override
+String get id;@override
+LoadSpec get load;@override
+String get name;Iterable<JsonSchema> get schema;Creates a JsonRef from Json map
+factory JsonRef.fromJson(Map<String, dynamic> data) =>
+ _\$JsonRefFromJson(data);JsonSchema getScheme(dynamic json, SchemaFinder find) => map(
+ ref: (_) => find(_.name),
+ union: (_) => Ref(json[_.key]).getScheme(json, find),
+ // orElse: () => throw StateError("Can't getEntity on \$runtimeType"),
+ );@optionalTypeArgs
+TResult map<TResult extends Object?>({
+ required TResult Function(Ref value) ref,
+ required TResult Function(Union value) union,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? mapOrNull<TResult extends Object?>({
+ TResult? Function(Ref value)? ref,
+ TResult? Function(Union value)? union,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeMap<TResult extends Object?>({
+ TResult Function(Ref value)? ref,
+ TResult Function(Union value)? union,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeWhen<TResult extends Object?>({
+ TResult Function(String name)? ref,
+ TResult Function(List<String> names, String key)? union,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;dynamic useId(dynamic id, JsonSchema scheme) => map(
+ ref: (_) => id,
+ union: (_) => {
+ 'id': id,
+ 'type': scheme.name,
+ },
+ // orElse: () => throw StateError("Can't getEntity on \$runtimeType"),
+ );@optionalTypeArgs
+TResult when<TResult extends Object?>({
+ required TResult Function(String name) ref,
+ required TResult Function(List<String> names, String key) union,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? whenOrNull<TResult extends Object?>({
+ TResult? Function(String name)? ref,
+ TResult? Function(List<String> names, String key)? union,
+}) =>
+ throw _privateConstructorUsedError;@FreezedUnionValue('JsonRefList.union')
+const factory JsonRefList.union(
+ List<String> names, {
+ @Default('type') String key,
+}) = UnionList;dynamic doCallback(dynamic json, DoCallback callback) =>
+ (json as List).map((item) => callback(item, schema)).toList();@optionalTypeArgs
+TResult map<TResult extends Object?>({
+ required TResult Function(RefList value) ref,
+ required TResult Function(UnionList value) union,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? mapOrNull<TResult extends Object?>({
+ TResult? Function(RefList value)? ref,
+ TResult? Function(UnionList value)? union,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeMap<TResult extends Object?>({
+ TResult Function(RefList value)? ref,
+ TResult Function(UnionList value)? union,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeWhen<TResult extends Object?>({
+ TResult Function(String name)? ref,
+ TResult Function(List<String> names, String key)? union,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;JsonRef get schema =>
+ map(ref: (_) => Ref(_.name), union: (_) => Union(_.names, key: _.key));Map<String, dynamic> toJson() => throw _privateConstructorUsedError;@optionalTypeArgs
+TResult when<TResult extends Object?>({
+ required TResult Function(String name) ref,
+ required TResult Function(List<String> names, String key) union,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? whenOrNull<TResult extends Object?>({
+ TResult? Function(String name)? ref,
+ TResult? Function(List<String> names, String key)? union,
+}) =>
+ throw _privateConstructorUsedError;@FreezedUnionValue('JsonRefValue.valueFrom')
+const factory JsonRefValue.valueFrom(String name) = ValueFrom;@JsonKey(ignore: true)
+\$JsonRefValueCopyWith<JsonRefValue> get copyWith =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult map<TResult extends Object?>({
+ required TResult Function(ValueFrom value) valueFrom,
+ required TResult Function(SlugFrom value) slugFrom,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? mapOrNull<TResult extends Object?>({
+ TResult? Function(ValueFrom value)? valueFrom,
+ TResult? Function(SlugFrom value)? slugFrom,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeMap<TResult extends Object?>({
+ TResult Function(ValueFrom value)? valueFrom,
+ TResult Function(SlugFrom value)? slugFrom,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeWhen<TResult extends Object?>({
+ TResult Function(String name)? valueFrom,
+ TResult Function(String name)? slugFrom,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;String get name => throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;@optionalTypeArgs
+TResult when<TResult extends Object?>({
+ required TResult Function(String name) valueFrom,
+ required TResult Function(String name) slugFrom,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? whenOrNull<TResult extends Object?>({
+ TResult? Function(String name)? valueFrom,
+ TResult? Function(String name)? slugFrom,
+}) =>
+ throw _privateConstructorUsedError;Creates a JsonSchema from Json map
+factory JsonSchema.fromJson(Map<String, dynamic> data) =>
+ _\$JsonSchemaFromJson(data);JsonSchema description
+@JsonKey(ignore: true)
+\$JsonSchemaCopyWith<JsonSchema> get copyWith =>
+ throw _privateConstructorUsedError;dynamic get definition => throw _privateConstructorUsedError;extra is a map of additional properties.
+@JsonEmptyMap()
+Map<String, dynamic> get extra => throw _privateConstructorUsedError;@optionalTypeArgs
+TResult map<TResult extends Object?>({
+ required TResult Function(Entity value) entity,
+ required TResult Function(Flat value) flat,
+ required TResult Function(Struct value) struct,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? mapOrNull<TResult extends Object?>({
+ TResult? Function(Entity value)? entity,
+ TResult? Function(Flat value)? flat,
+ TResult? Function(Struct value)? struct,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeMap<TResult extends Object?>({
+ TResult Function(Entity value)? entity,
+ TResult Function(Flat value)? flat,
+ TResult Function(Struct value)? struct,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeWhen<TResult extends Object?>({
+ TResult Function(String name, Map<String, IJsonSchema> definition,
+ String key, @JsonEmptyMap() Map<String, dynamic> extra)?
+ entity,
+ TResult Function(
+ String name,
+ Map<String, IJsonSchema> definition,
+ String key,
+ List<String> entityPath,
+ List<List<String>> includePath,
+ bool addMissingKeys,
+ @JsonEmptyMap() Map<String, dynamic> extra)?
+ flat,
+ TResult Function(
+ String name,
+ @JsonKey(fromJson: IJsonSchema.structFromJson) dynamic definition,
+ @JsonEmptyMap() Map<String, dynamic> extra)?
+ struct,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;String get name => throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;@optionalTypeArgs
+TResult when<TResult extends Object?>({
+ required TResult Function(String name, Map<String, IJsonSchema> definition,
+ String key, @JsonEmptyMap() Map<String, dynamic> extra)
+ entity,
+ required TResult Function(
+ String name,
+ Map<String, IJsonSchema> definition,
+ String key,
+ List<String> entityPath,
+ List<List<String>> includePath,
+ bool addMissingKeys,
+ @JsonEmptyMap() Map<String, dynamic> extra)
+ flat,
+ required TResult Function(
+ String name,
+ @JsonKey(fromJson: IJsonSchema.structFromJson) dynamic definition,
+ @JsonEmptyMap() Map<String, dynamic> extra)
+ struct,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? whenOrNull<TResult extends Object?>({
+ TResult? Function(String name, Map<String, IJsonSchema> definition,
+ String key, @JsonEmptyMap() Map<String, dynamic> extra)?
+ entity,
+ TResult? Function(
+ String name,
+ Map<String, IJsonSchema> definition,
+ String key,
+ List<String> entityPath,
+ List<List<String>> includePath,
+ bool addMissingKeys,
+ @JsonEmptyMap() Map<String, dynamic> extra)?
+ flat,
+ TResult? Function(
+ String name,
+ @JsonKey(fromJson: IJsonSchema.structFromJson) dynamic definition,
+ @JsonEmptyMap() Map<String, dynamic> extra)?
+ struct,
+}) =>
+ throw _privateConstructorUsedError;const factory JsonTransformSpec(final Iterable<JsonSchema> schema) =
+ _\$JsonTransformSpec;@override
+@JsonKey(ignore: true)
+_\$\$JsonTransformSpecCopyWith<_\$JsonTransformSpec> get copyWith =>
+ throw _privateConstructorUsedError;@override
+Iterable<JsonSchema> get schema;const factory LoadSpec.ungraph() = UngraphLoadSpec;@optionalTypeArgs
+TResult map<TResult extends Object?>({
+ required TResult Function(UngraphLoadSpec value) ungraph,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? mapOrNull<TResult extends Object?>({
+ TResult? Function(UngraphLoadSpec value)? ungraph,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeMap<TResult extends Object?>({
+ TResult Function(UngraphLoadSpec value)? ungraph,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeWhen<TResult extends Object?>({
+ TResult Function()? ungraph,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;@optionalTypeArgs
+TResult when<TResult extends Object?>({
+ required TResult Function() ungraph,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? whenOrNull<TResult extends Object?>({
+ TResult? Function()? ungraph,
+}) =>
+ throw _privateConstructorUsedError;const factory LocalFileSpec() = _\$LocalFileSpec;factory ModuleSpec.fromJson(Map<String, dynamic> json) =>
+ _\$ModuleSpecFromJson(json);@JsonKey(ignore: true)
+\$ModuleSpecCopyWith<ModuleSpec> get copyWith =>
+ throw _privateConstructorUsedError;@override
+ExtractSpec get extractSpec => map(
+ custom: (_) => _.extract,
+ json: (_) => const JsonExtractSpec(),
+ );Pattern get fileMatcher => throw _privateConstructorUsedError;String get id => throw _privateConstructorUsedError;LoadSpec get load => throw _privateConstructorUsedError;@override
+LoadSpec get loadSpec => map(
+ custom: (_) => _.load,
+ json: (_) => _.load,
+ );@optionalTypeArgs
+TResult map<TResult extends Object?>({
+ required TResult Function(CustomModule value) custom,
+ required TResult Function(JsonModule value) json,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? mapOrNull<TResult extends Object?>({
+ TResult? Function(CustomModule value)? custom,
+ TResult? Function(JsonModule value)? json,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeMap<TResult extends Object?>({
+ TResult Function(CustomModule value)? custom,
+ TResult Function(JsonModule value)? json,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeWhen<TResult extends Object?>({
+ TResult Function(String id, String name, Pattern fileMatcher,
+ ExtractSpec extract, TransformSpec transform, LoadSpec load)?
+ custom,
+ TResult Function(String id, String name, Pattern fileMatcher,
+ Iterable<JsonSchema> schema, LoadSpec load)?
+ json,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;String get name => throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;@override
+TransformSpec get transformSpec => map(
+ custom: (_) => _.transform,
+ json: (_) => JsonTransformSpec(_.schema),
+ );@optionalTypeArgs
+TResult when<TResult extends Object?>({
+ required TResult Function(String id, String name, Pattern fileMatcher,
+ ExtractSpec extract, TransformSpec transform, LoadSpec load)
+ custom,
+ required TResult Function(String id, String name, Pattern fileMatcher,
+ Iterable<JsonSchema> schema, LoadSpec load)
+ json,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? whenOrNull<TResult extends Object?>({
+ TResult? Function(String id, String name, Pattern fileMatcher,
+ ExtractSpec extract, TransformSpec transform, LoadSpec load)?
+ custom,
+ TResult? Function(String id, String name, Pattern fileMatcher,
+ Iterable<JsonSchema> schema, LoadSpec load)?
+ json,
+}) =>
+ throw _privateConstructorUsedError;factory Node.fromJson(Map<String, dynamic> json) => _\$NodeFromJson(json);@JsonKey(ignore: true)
+\$NodeCopyWith<Node> get copyWith => throw _privateConstructorUsedError;String? get id => throw _privateConstructorUsedError;@override
+List<String> get labels => [specSlug];@JsonEmptyMap()
+Map<String, dynamic> get properties => throw _privateConstructorUsedError;String get specSlug =>
+ throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;factory NodeSpec.fromJson(Map<String, dynamic> json) =>
+ _\$NodeSpecFromJson(json);@JsonKey(ignore: true)
+\$NodeSpecCopyWith<NodeSpec> get copyWith =>
+ throw _privateConstructorUsedError;String? get id => throw _privateConstructorUsedError;List<String> get labels => [slug];String get name => throw _privateConstructorUsedError;List<PropSpec> get propSpecs => throw _privateConstructorUsedError;String get slug => slugged ?? slugify(name, delimiter: '_');String? get slugged => throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;const factory PropSpec({
+ required String name,
+ required String description,
+ required String type,
+}) = _PropSpec;@JsonKey(ignore: true)
+\$PropSpecCopyWith<PropSpec> get copyWith =>
+ throw _privateConstructorUsedError;String get description => throw _privateConstructorUsedError;String get name => throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;String get type => throw _privateConstructorUsedError;factory Ref.fromJson(Map<String, dynamic> json) = _\$Ref.fromJson;@JsonKey(ignore: true)
+_\$\$RefCopyWith<_\$Ref> get copyWith => throw _privateConstructorUsedError;String get name;factory RefList.fromJson(Map<String, dynamic> json) = _\$RefList.fromJson;@JsonKey(ignore: true)
+_\$\$RefListCopyWith<_\$RefList> get copyWith =>
+ throw _privateConstructorUsedError;String get name;factory RetrieveSpec.fromJson(Map<String, dynamic> json) =>
+ _\$RetrieveSpecFromJson(json);@optionalTypeArgs
+TResult map<TResult extends Object?>({
+ required TResult Function(LocalFileSpec value) localFile,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? mapOrNull<TResult extends Object?>({
+ TResult? Function(LocalFileSpec value)? localFile,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeMap<TResult extends Object?>({
+ TResult Function(LocalFileSpec value)? localFile,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeWhen<TResult extends Object?>({
+ TResult Function()? localFile,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;@optionalTypeArgs
+TResult when<TResult extends Object?>({
+ required TResult Function() localFile,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? whenOrNull<TResult extends Object?>({
+ TResult? Function()? localFile,
+}) =>
+ throw _privateConstructorUsedError;typedef SchemaFinder = JsonSchema Function(String name);Settings description
+const factory Settings({
+ /// [themeMode] is the current theme mode set by the settings.
+ required ThemeMode themeMode,
+
+ /// [extra] is a map of additional properties.
+ @JsonEmptyMap() @Default({}) Map<String, dynamic> extra,
+}) = _Settings;Settings description
+@JsonKey(ignore: true)
+\$SettingsCopyWith<Settings> get copyWith =>
+ throw _privateConstructorUsedError;extra is a map of additional properties.
+@JsonEmptyMap()
+Map<String, dynamic> get extra => throw _privateConstructorUsedError;themeMode is the current theme mode set by the settings.
+ThemeMode get themeMode => throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;factory SlugFrom.fromJson(Map<String, dynamic> json) = _\$SlugFrom.fromJson;@override
+@JsonKey(ignore: true)
+_\$\$SlugFromCopyWith<_\$SlugFrom> get copyWith =>
+ throw _privateConstructorUsedError;@override
+String get name;factory Struct.fromJson(Map<String, dynamic> json) = _\$Struct.fromJson;@override
+@JsonKey(ignore: true)
+_\$\$StructCopyWith<_\$Struct> get copyWith =>
+ throw _privateConstructorUsedError;@override
+@JsonKey(fromJson: IJsonSchema.structFromJson)
+dynamic get definition;extra is a map of additional properties.
+@override
+
+/// [extra] is a map of additional properties.
+@JsonEmptyMap()
+Map<String, dynamic> get extra;@override
+String get name;const factory TransformSpec.json(
+ Iterable<JsonSchema> schema,
+) = JsonTransformSpec;@JsonKey(ignore: true)
+\$TransformSpecCopyWith<TransformSpec> get copyWith =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult map<TResult extends Object?>({
+ required TResult Function(JsonTransformSpec value) json,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? mapOrNull<TResult extends Object?>({
+ TResult? Function(JsonTransformSpec value)? json,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeMap<TResult extends Object?>({
+ TResult Function(JsonTransformSpec value)? json,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeWhen<TResult extends Object?>({
+ TResult Function(Iterable<JsonSchema> schema)? json,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;Iterable<JsonSchema> get schema => throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;@optionalTypeArgs
+TResult when<TResult extends Object?>({
+ required TResult Function(Iterable<JsonSchema> schema) json,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? whenOrNull<TResult extends Object?>({
+ TResult? Function(Iterable<JsonSchema> schema)? json,
+}) =>
+ throw _privateConstructorUsedError;factory UngraphLoadSpec.fromJson(Map<String, dynamic> json) =
+ _\$UngraphLoadSpec.fromJson;factory Union.fromJson(Map<String, dynamic> json) = _\$Union.fromJson;@JsonKey(ignore: true)
+_\$\$UnionCopyWith<_\$Union> get copyWith => throw _privateConstructorUsedError;String get key;List<String> get names;const factory UnionList(final List<String> names, {final String key}) =
+ _\$UnionList;@JsonKey(ignore: true)
+_\$\$UnionListCopyWith<_\$UnionList> get copyWith =>
+ throw _privateConstructorUsedError;String get key;List<String> get names;factory UnpackSpec.fromJson(Map<String, dynamic> json) =>
+ _\$UnpackSpecFromJson(json);@JsonKey(ignore: true)
+\$UnpackSpecCopyWith<UnpackSpec> get copyWith =>
+ throw _privateConstructorUsedError;FileSpec get fileSpec => throw _privateConstructorUsedError;String? get id => throw _privateConstructorUsedError;UnpackState get initialState => UnpackState(
+ specId: id!,
+ step: UnpackStep.initial,
+ // selectedModules: modules,
+ );Iterable<ModuleSpec> get modules => throw _privateConstructorUsedError;String get name => throw _privateConstructorUsedError;RetrieveSpec get retrieveSpec => throw _privateConstructorUsedError;@override
+String get slug => slugify(name);Map<String, dynamic> toJson() => throw _privateConstructorUsedError;factory UnpackState.fromJson(Map<String, dynamic> json) =>
+ _\$UnpackStateFromJson(json);@JsonKey(ignore: true)
+\$UnpackStateCopyWith<UnpackState> get copyWith =>
+ throw _privateConstructorUsedError;String? get filePath => throw _privateConstructorUsedError;String? get id => throw _privateConstructorUsedError;Iterable<ModuleSpec>? get selectedModules =>
+ throw _privateConstructorUsedError;String get specId => throw _privateConstructorUsedError;UnpackStep get step => throw _privateConstructorUsedError;Map<String, dynamic> toJson() => throw _privateConstructorUsedError;[initial, configure, retrieve, prepare, process, complete, error]
+ A constant List of the values in this enum, in order of their declaration.
+factory ValueFrom.fromJson(Map<String, dynamic> json) = _\$ValueFrom.fromJson;@override
+@JsonKey(ignore: true)
+_\$\$ValueFromCopyWith<_\$ValueFrom> get copyWith =>
+ throw _privateConstructorUsedError;@override
+String get name;factory ZipFileSpec.fromJson(Map<String, dynamic> json) =
+ _\$ZipFileSpec.fromJson;const JsonDateTime();@override
+fromJson(_) {
+ if (_ is DateTime) return _;
+ if (_ is int) return DateTime.fromMillisecondsSinceEpoch(_);
+
+ return DateTime.parse(_);
+}@override
+toJson(_) => _.toIso8601String();const JsonEmptyMap();@override
+fromJson(_) => _?.cast<String, dynamic>() ?? {};@override
+toJson(_) => _.keys.isNotEmpty ? _ : null;const JsonString();@override
+fromJson(_) => _.toString();@override
+toJson(_) => _.toString();const JsonVersion();@override
+fromJson(_) => Version.parse(_);@override
+toJson(_) => _.toString();const JsonVersionConstraint();@override
+fromJson(_) => VersionConstraint.parse(_);@override
+toJson(_) => _.toString();const PatternConverter();@override
+fromJson(_) {
+ switch (_['runtimeType']) {
+ case 'RegExp':
+ return RegExp(_['pattern']!);
+ case 'String':
+ return _['pattern']!;
+ default:
+ throw CheckedFromJsonException(_, 'runtimeType', 'Pattern',
+ 'Invalid union type "\${_['runtimeType']}"!');
+ }
+}@override
+toJson(_) {
+ switch (_.runtimeType) {
+ case RegExp:
+ return {
+ 'runtimeType': 'RegExp',
+ 'pattern': (_ as RegExp).pattern,
+ };
+ case String:
+ return {
+ 'runtimeType': 'String',
+ 'pattern': _ as String,
+ };
+ default:
+ throw StateError('Invalid union type "\${_.runtimeType}"!');
+ }
+}AnalyticService description
+AnalyticService({required RudderController rudder}) : _rudder = rudder {
+ if (Firebase.apps.isEmpty) {
+ throw Exception(
+ "Firebase Analytics must be initialized for RudderStacks' Firebase Integration.",
+ );
+ }
+
+ getCurrentContext().then((value) => _context = value);
+}AnalyticService description
+AnalyticContext? get context => _context;Future<AnalyticContext?> getCurrentContext() async => _rudder
+ .getRudderContext()
+ .then((value) => value != null ? AnalyticContext(map: value) : null);void trackEvent(String eventName) => _rudder.track(eventName);void trackScreen(String screenName) => _rudder.screen(screenName);ErrorService description
+static Future<void> recordError(
+ dynamic exception,
+ StackTrace? stack, {
+ bool fatal = false,
+}) async {
+ await Sentry.captureException(
+ exception,
+ stackTrace: stack,
+ // TODO: Report non fatal errors to Sentry via \`Sentry.captureEvent\`
+ );
+
+ // Pass all uncaught errors from the framework to Crashlytics.
+ // https://firebase.google.com/docs/crashlytics/customize-crash-reports?platform=flutter
+ await FirebaseCrashlytics.instance.recordError(
+ exception,
+ stack,
+ fatal: fatal,
+ );
+}static Future<void> recordFlutterError(
+ FlutterErrorDetails flutterErrorDetails,
+) async {
+ await FirebaseCrashlytics.instance.recordFlutterError(
+ flutterErrorDetails,
+ );
+}static void recordIsolateError() =>
+ Isolate.current.addErrorListener(RawReceivePort((pair) async {
+ final List<dynamic> errorAndStacktrace = pair;
+ await recordError(
+ errorAndStacktrace.first,
+ errorAndStacktrace.last,
+ );
+ }).sendPort);static runAppGuarded(Widget app) => runZonedGuarded(
+ () {
+ FlutterError.onError = recordFlutterError;
+ if (!kIsWeb) recordIsolateError();
+
+ return runApp(app);
+ },
+ (error, stackTrace) => recordError(error, stackTrace, fatal: true),
+ );InfoService description
+const InfoService({
+ AnalyticService? analytic,
+}) : _analytic = analytic;InfoService description
+CFBundleDisplayName on iOS, application/label on Android.
+ CFBundleVersion on iOS, versionCode on Android.
+ bundleIdentifier on iOS, getPackageName on Android.
+ CFBundleShortVersionString on iOS, versionName on Android.
+ String? get analyticId => _analytic!.context?.anonymousId;Load app information from the platform.
+The app name. CFBundleDisplayName on iOS, application/label on Android.
// Future<void> load() async {
+// _package ??= await PackageInfo.fromPlatform();
+// _analytic ??= AnalyticService(rudder: RudderController.instance);
+// }
+
+// PackageInfo
+
+/// The app name. \`CFBundleDisplayName\` on iOS, \`application/label\` on Android.
+String get appName => package!.appName;The build number. CFBundleVersion on iOS, versionCode on Android.
String get buildNumber => package!.buildNumber;The build signature. Empty string on iOS, signing key signature (hex) on Android.
+String get buildSignature => package!.buildSignature;The installer store. Indicates through which store this application was installed.
+String? get installerStore => package!.installerStore;@internal
+static PackageInfo? package;The package name. bundleIdentifier on iOS, getPackageName on Android.
String get packageName => package!.packageName;The package version. CFBundleShortVersionString on iOS, versionName on Android.
String get version => package!.version;PerformanceService description
+const PerformanceService({
+ required FirebasePerformance performance,
+}) : _performance = performance;PerformanceService description
+Future<void> initializeMonitoringServices({
+ required String sentryDsn,
+ required FirebaseOptions firebaseOptions,
+}) async {
+ await Firebase.initializeApp(
+ options: firebaseOptions,
+ );
+ await Sentry.init((options) {
+ options.dsn = sentryDsn;
+ options.tracesSampleRate = 1.0;
+ });
+ await PackageInfo.fromPlatform().then(
+ (value) => InfoService.package = value,
+ );
+}Color get onDisabled => withOpacity(UnColorStates.disabled);Color get onDisabledContent => withOpacity(UnColorStates.disabledContent);Color get onDragged => withOpacity(UnColorStates.dragged);Color get onFocus => withOpacity(UnColorStates.focus);Color get onHover => withOpacity(UnColorStates.hover);Color get onPressed => withOpacity(UnColorStates.pressed);const CustomColors({
+ required this.sourceGold,
+ required this.gold,
+ required this.onGold,
+ required this.goldContainer,
+ required this.onGoldContainer,
+ required this.sourceVanilla,
+ required this.vanilla,
+ required this.onVanilla,
+ required this.vanillaContainer,
+ required this.onVanillaContainer,
+ required this.sourceMauve,
+ required this.mauve,
+ required this.onMauve,
+ required this.mauveContainer,
+ required this.onMauveContainer,
+});Defines a set of custom colors, each comprised of 4 complementary tones.
+See also:
+ +dynamic's ColorScheme.primary.
+
+
+Creates a copy of this theme extension with the given fields +replaced by the non-null parameter values.
+@override
+CustomColors copyWith({
+ Color? sourceGold,
+ Color? gold,
+ Color? onGold,
+ Color? goldContainer,
+ Color? onGoldContainer,
+ Color? sourceVanilla,
+ Color? vanilla,
+ Color? onVanilla,
+ Color? vanillaContainer,
+ Color? onVanillaContainer,
+ Color? sourceMauve,
+ Color? mauve,
+ Color? onMauve,
+ Color? mauveContainer,
+ Color? onMauveContainer,
+}) {
+ return CustomColors(
+ sourceGold: sourceGold ?? this.sourceGold,
+ gold: gold ?? this.gold,
+ onGold: onGold ?? this.onGold,
+ goldContainer: goldContainer ?? this.goldContainer,
+ onGoldContainer: onGoldContainer ?? this.onGoldContainer,
+ sourceVanilla: sourceVanilla ?? this.sourceVanilla,
+ vanilla: vanilla ?? this.vanilla,
+ onVanilla: onVanilla ?? this.onVanilla,
+ vanillaContainer: vanillaContainer ?? this.vanillaContainer,
+ onVanillaContainer: onVanillaContainer ?? this.onVanillaContainer,
+ sourceMauve: sourceMauve ?? this.sourceMauve,
+ mauve: mauve ?? this.mauve,
+ onMauve: onMauve ?? this.onMauve,
+ mauveContainer: mauveContainer ?? this.mauveContainer,
+ onMauveContainer: onMauveContainer ?? this.onMauveContainer,
+ );
+}final Color? gold;final Color? goldContainer;Returns an instance of CustomColors in which the following custom
+colors are harmonized with dynamic's ColorScheme.primary.
See also:
+ +CustomColors harmonized(ColorScheme dynamic) {
+ return copyWith(
+ sourceGold: sourceGold!.harmonizeWith(dynamic.primary),
+ gold: gold!.harmonizeWith(dynamic.primary),
+ onGold: onGold!.harmonizeWith(dynamic.primary),
+ goldContainer: goldContainer!.harmonizeWith(dynamic.primary),
+ onGoldContainer: onGoldContainer!.harmonizeWith(dynamic.primary),
+ sourceVanilla: sourceVanilla!.harmonizeWith(dynamic.primary),
+ vanilla: vanilla!.harmonizeWith(dynamic.primary),
+ onVanilla: onVanilla!.harmonizeWith(dynamic.primary),
+ vanillaContainer: vanillaContainer!.harmonizeWith(dynamic.primary),
+ onVanillaContainer: onVanillaContainer!.harmonizeWith(dynamic.primary),
+ sourceMauve: sourceMauve!.harmonizeWith(dynamic.primary),
+ mauve: mauve!.harmonizeWith(dynamic.primary),
+ onMauve: onMauve!.harmonizeWith(dynamic.primary),
+ mauveContainer: mauveContainer!.harmonizeWith(dynamic.primary),
+ onMauveContainer: onMauveContainer!.harmonizeWith(dynamic.primary),
+ );
+}Linearly interpolate with another ThemeExtension object.
+The t argument represents position on the timeline, with 0.0 meaning
+that the interpolation has not started, returning a (or something
+equivalent to a), 1.0 meaning that the interpolation has finished,
+returning b (or something equivalent to b), and values in between
+meaning that the interpolation is at the relevant point on the timeline
+between a and b. The interpolation can be extrapolated beyond 0.0 and
+1.0, so negative values and values greater than 1.0 are valid (and can
+easily be generated by curves such as Curves.elasticInOut).
Values for t are usually obtained from an Animation<double>, such as
+an AnimationController.
@override
+CustomColors lerp(ThemeExtension<CustomColors>? other, double t) {
+ if (other is! CustomColors) {
+ return this;
+ }
+
+ return CustomColors(
+ sourceGold: Color.lerp(sourceGold, other.sourceGold, t),
+ gold: Color.lerp(gold, other.gold, t),
+ onGold: Color.lerp(onGold, other.onGold, t),
+ goldContainer: Color.lerp(goldContainer, other.goldContainer, t),
+ onGoldContainer: Color.lerp(onGoldContainer, other.onGoldContainer, t),
+ sourceVanilla: Color.lerp(sourceVanilla, other.sourceVanilla, t),
+ vanilla: Color.lerp(vanilla, other.vanilla, t),
+ onVanilla: Color.lerp(onVanilla, other.onVanilla, t),
+ vanillaContainer: Color.lerp(vanillaContainer, other.vanillaContainer, t),
+ onVanillaContainer:
+ Color.lerp(onVanillaContainer, other.onVanillaContainer, t),
+ sourceMauve: Color.lerp(sourceMauve, other.sourceMauve, t),
+ mauve: Color.lerp(mauve, other.mauve, t),
+ onMauve: Color.lerp(onMauve, other.onMauve, t),
+ mauveContainer: Color.lerp(mauveContainer, other.mauveContainer, t),
+ onMauveContainer: Color.lerp(onMauveContainer, other.onMauveContainer, t),
+ );
+}final Color? mauve;final Color? mauveContainer;final Color? onGold;final Color? onGoldContainer;final Color? onMauve;final Color? onMauveContainer;final Color? onVanilla;final Color? onVanillaContainer;final Color? sourceGold;final Color? sourceMauve;final Color? sourceVanilla;final Color? vanilla;final Color? vanillaContainer;const ElevationInfo(
+ this.level,
+ this.elevation,
+ this.overlayPercent,
+ this.layers,
+);final double elevation;final List<BoxShadow> layers;final int level;final int overlayPercent;GENERATED CODE - DO NOT MODIFY BY HAND
+FlutterGen
+Font family: Inter
+static const String inter = 'Inter';Font family: Literata
+static const String literata = 'Literata';Font family: MaterialSymbolsRounded
+static const String materialSymbolsRounded = 'MaterialSymbolsRounded';ColorScheme harmonizeWith(Color color) => ColorScheme(
+ brightness: brightness,
+ primary: primary.harmonizeWith(color),
+ onPrimary: onPrimary.harmonizeWith(color),
+ primaryContainer: primaryContainer.harmonizeWith(color),
+ onPrimaryContainer: onPrimaryContainer.harmonizeWith(color),
+ secondary: secondary.harmonizeWith(color),
+ onSecondary: onSecondary.harmonizeWith(color),
+ secondaryContainer: secondaryContainer.harmonizeWith(color),
+ onSecondaryContainer: onSecondaryContainer.harmonizeWith(color),
+ tertiary: tertiary.harmonizeWith(color),
+ onTertiary: onTertiary.harmonizeWith(color),
+ tertiaryContainer: tertiaryContainer.harmonizeWith(color),
+ onTertiaryContainer: onTertiaryContainer.harmonizeWith(color),
+ error: error.harmonizeWith(color),
+ onError: onError.harmonizeWith(color),
+ errorContainer: errorContainer.harmonizeWith(color),
+ onErrorContainer: onErrorContainer.harmonizeWith(color),
+ background: background.harmonizeWith(color),
+ onBackground: onBackground.harmonizeWith(color),
+ surface: surface.harmonizeWith(color),
+ onSurface: onSurface.harmonizeWith(color),
+ surfaceVariant: surfaceVariant.harmonizeWith(color),
+ onSurfaceVariant: onSurfaceVariant.harmonizeWith(color),
+ outline: outline.harmonizeWith(color),
+ shadow: shadow.harmonizeWith(color),
+ inverseSurface: inverseSurface.harmonizeWith(color),
+ onInverseSurface: onInverseSurface.harmonizeWith(color),
+ inversePrimary: inversePrimary.harmonizeWith(color),
+ );Namespace for Default UnselfStyle Breakpoints
+Min width for a large layout.
+static const double large = 840;Min width for a medium layout.
+static const double medium = 600;Min width for a small layout.
+static const double small = 0;.12
+ .38
+ .16
+ .12
+ .08
+ .12
+ static const disabled = .12;static const disabledContent = .38;static const dragged = .16;static const focus = .12;static const hover = .08;static const pressed = .12;Defines the color themes for the UnselfStyle UI.
+ColorScheme(brightness: Brightness.dark, primary: Color(0xFFC1C1FF), onPrimary: Color(0xFF242478), primaryContainer: Color(0xFF3B3D8F), onPrimaryContainer: Color(0xFFE1DFFF), secondary: Color(0xFFC6C4…
+ CustomColors(sourceGold: Color(0xFFE2C197), gold: Color(0xFFFFB950), onGold: Color(0xFF452B00), goldContainer: Color(0xFF624000), onGoldContainer: Color(0xFFFFDDB3), sourceVanilla: Color(0xFFC1CBA2), …
+ ColorScheme(brightness: Brightness.light, primary: Color(0xFF5455A9), onPrimary: Color(0xFFFFFFFF), primaryContainer: Color(0xFFE1DFFF), onPrimaryContainer: Color(0xFF0B0664), secondary: Color(0xFF5D5…
+ CustomColors(sourceGold: Color(0xFFE2C197), gold: Color(0xFF825500), onGold: Color(0xFFFFFFFF), goldContainer: Color(0xFFFFDDB3), onGoldContainer: Color(0xFF291800), sourceVanilla: Color(0xFFC1CBA2), …
+ static const ColorScheme darkColorStyle = ColorScheme(
+ brightness: Brightness.dark,
+ primary: Color(0xFFC1C1FF),
+ onPrimary: Color(0xFF242478),
+ primaryContainer: Color(0xFF3B3D8F),
+ onPrimaryContainer: Color(0xFFE1DFFF),
+ secondary: Color(0xFFC6C4DD),
+ onSecondary: Color(0xFF2F2F42),
+ secondaryContainer: Color(0xFF454559),
+ onSecondaryContainer: Color(0xFFE2E0F9),
+ tertiary: Color(0xFFE9B9D3),
+ onTertiary: Color(0xFF46263A),
+ tertiaryContainer: Color(0xFF5F3C51),
+ onTertiaryContainer: Color(0xFFFFD8EC),
+ error: Color(0xFFFFB4AB),
+ errorContainer: Color(0xFF93000A),
+ onError: Color(0xFF690005),
+ onErrorContainer: Color(0xFFFFDAD6),
+ background: Color(0xFF1C1B1F),
+ onBackground: Color(0xFFE5E1E6),
+ surface: Color(0xFF1C1B1F),
+ onSurface: Color(0xFFE5E1E6),
+ surfaceVariant: Color(0xFF47464F),
+ onSurfaceVariant: Color(0xFFC8C5D0),
+ outline: Color(0xFF918F9A),
+ onInverseSurface: Color(0xFF1C1B1F),
+ inverseSurface: Color(0xFFE5E1E6),
+ inversePrimary: Color(0xFF5455A9),
+ shadow: Color(0xFF000000),
+ surfaceTint: Color(0xFFC1C1FF),
+);static const CustomColors darkCustomColors = CustomColors(
+ sourceGold: Color(0xFFE2C197),
+ gold: Color(0xFFFFB950),
+ onGold: Color(0xFF452B00),
+ goldContainer: Color(0xFF624000),
+ onGoldContainer: Color(0xFFFFDDB3),
+ sourceVanilla: Color(0xFFC1CBA2),
+ vanilla: Color(0xFFB4D269),
+ onVanilla: Color(0xFF273500),
+ vanillaContainer: Color(0xFF3A4D00),
+ onVanillaContainer: Color(0xFFD0EE82),
+ sourceMauve: Color(0xFFE9BAC7),
+ mauve: Color(0xFFFFB0C9),
+ onMauve: Color(0xFF5E1133),
+ mauveContainer: Color(0xFF7B294A),
+ onMauveContainer: Color(0xFFFFD9E3),
+);static const ColorScheme lightColorStyle = ColorScheme(
+ brightness: Brightness.light,
+ primary: Color(0xFF5455A9),
+ onPrimary: Color(0xFFFFFFFF),
+ primaryContainer: Color(0xFFE1DFFF),
+ onPrimaryContainer: Color(0xFF0B0664),
+ secondary: Color(0xFF5D5C72),
+ onSecondary: Color(0xFFFFFFFF),
+ secondaryContainer: Color(0xFFE2E0F9),
+ onSecondaryContainer: Color(0xFF1A1A2C),
+ tertiary: Color(0xFF795369),
+ onTertiary: Color(0xFFFFFFFF),
+ tertiaryContainer: Color(0xFFFFD8EC),
+ onTertiaryContainer: Color(0xFF2E1125),
+ error: Color(0xFFBA1A1A),
+ errorContainer: Color(0xFFFFDAD6),
+ onError: Color(0xFFFFFFFF),
+ onErrorContainer: Color(0xFF410002),
+ background: Color(0xFFFFFBFF),
+ onBackground: Color(0xFF1C1B1F),
+ surface: Color(0xFFFFFBFF),
+ onSurface: Color(0xFF1C1B1F),
+ surfaceVariant: Color(0xFFE4E1EC),
+ onSurfaceVariant: Color(0xFF47464F),
+ outline: Color(0xFF777680),
+ onInverseSurface: Color(0xFFF3EFF4),
+ inverseSurface: Color(0xFF313034),
+ inversePrimary: Color(0xFFC1C1FF),
+ shadow: Color(0xFF000000),
+ surfaceTint: Color(0xFF5455A9),
+);static const CustomColors lightCustomColors = CustomColors(
+ sourceGold: Color(0xFFE2C197),
+ gold: Color(0xFF825500),
+ onGold: Color(0xFFFFFFFF),
+ goldContainer: Color(0xFFFFDDB3),
+ onGoldContainer: Color(0xFF291800),
+ sourceVanilla: Color(0xFFC1CBA2),
+ vanilla: Color(0xFF4F6703),
+ onVanilla: Color(0xFFFFFFFF),
+ vanillaContainer: Color(0xFFD0EE82),
+ onVanillaContainer: Color(0xFF151F00),
+ sourceMauve: Color(0xFFE9BAC7),
+ mauve: Color(0xFF984062),
+ onMauve: Color(0xFFFFFFFF),
+ mauveContainer: Color(0xFFFFD9E3),
+ onMauveContainer: Color(0xFF3E001E),
+);static const ExtraLarge = UnSizes.size09 + .0;static const ExtraSmall = UnSizes.size01 + .0;static const Large = UnSizes.size05 + .0;static const Medium = UnSizes.size03 + .0;static const None = UnSizes.size00 + .0;static const Small = UnSizes.size02 + .0;UnSizes.size09 + .0
+ UnSizes.size01 + .0
+ UnSizes.size05 + .0
+ UnSizes.size03 + .0
+ UnSizes.size00 + .0
+ UnSizes.size02 + .0
+ 0.6
+ static const smoothFactor = 0.6;Duration(milliseconds: 500)
+ Duration(milliseconds: 200)
+ Duration(milliseconds: 300)
+ Duration(milliseconds: 100)
+ Duration(milliseconds: 400)
+ static const Duration dalayed = Duration(milliseconds: 500);static const Duration fast = Duration(milliseconds: 200);static const Duration moderate = Duration(milliseconds: 300);static const Duration rapid = Duration(milliseconds: 100);static const Duration slow = Duration(milliseconds: 400);Curves.bounceIn
+ Curves.bounceInOut
+ Curves.bounceOut
+ Curves.decelerate
+ Curves.ease
+ Curves.easeIn
+ Curves.easeInBack
+ Curves.easeInCirc
+ Curves.easeInCubic
+ Curves.easeInExpo
+ Curves.easeInOut
+ Curves.easeInOutBack
+ Curves.easeInOutCirc
+ Curves.easeInOutCubic
+ Curves.easeInOutCubicEmphasized
+ Curves.easeInOutExpo
+ Curves.easeInOutQuad
+ Curves.easeInOutQuart
+ Curves.easeInOutQuint
+ Curves.easeInOutSine
+ Curves.easeInQuad
+ Curves.easeInQuart
+ Curves.easeInQuint
+ Curves.easeInSine
+ Curves.easeInToLinear
+ Curves.easeOut
+ Curves.easeOutBack
+ Curves.easeOutCirc
+ Curves.easeOutCubic
+ Curves.easeOutExpo
+ Curves.easeOutQuad
+ Curves.easeOutQuart
+ Curves.easeOutQuint
+ Curves.easeOutSine
+ Curves.elasticIn
+ Curves.elasticInOut
+ Curves.elasticOut
+ Curves.fastLinearToSlowEaseIn
+ Curves.fastOutSlowIn
+ Curves.linear
+ Curves.linearToEaseOut
+ Curves.slowMiddle
+ static const Curve bounceIn = Curves.bounceIn;static const Curve bounceInOut = Curves.bounceInOut;static const Curve bounceOut = Curves.bounceOut;static const Curve decelerate = Curves.decelerate;static const Cubic ease = Curves.ease;static const Cubic easeIn = Curves.easeIn;static const Cubic easeInBack = Curves.easeInBack;static const Cubic easeInCirc = Curves.easeInCirc;static const Cubic easeInCubic = Curves.easeInCubic;static const Cubic easeInExpo = Curves.easeInExpo;static const Cubic easeInOut = Curves.easeInOut;static const Cubic easeInOutBack = Curves.easeInOutBack;static const Cubic easeInOutCirc = Curves.easeInOutCirc;static const Cubic easeInOutCubic = Curves.easeInOutCubic;static const ThreePointCubic easeInOutCubicEmphasized =
+ Curves.easeInOutCubicEmphasized;static const Cubic easeInOutExpo = Curves.easeInOutExpo;static const Cubic easeInOutQuad = Curves.easeInOutQuad;static const Cubic easeInOutQuart = Curves.easeInOutQuart;static const Cubic easeInOutQuint = Curves.easeInOutQuint;static const Cubic easeInOutSine = Curves.easeInOutSine;static const Cubic easeInQuad = Curves.easeInQuad;static const Cubic easeInQuart = Curves.easeInQuart;static const Cubic easeInQuint = Curves.easeInQuint;static const Cubic easeInSine = Curves.easeInSine;static const Cubic easeInToLinear = Curves.easeInToLinear;static const Cubic easeOut = Curves.easeOut;static const Cubic easeOutBack = Curves.easeOutBack;static const Cubic easeOutCirc = Curves.easeOutCirc;static const Cubic easeOutCubic = Curves.easeOutCubic;static const Cubic easeOutExpo = Curves.easeOutExpo;static const Cubic easeOutQuad = Curves.easeOutQuad;static const Cubic easeOutQuart = Curves.easeOutQuart;static const Cubic easeOutQuint = Curves.easeOutQuint;static const Cubic easeOutSine = Curves.easeOutSine;static const ElasticInCurve elasticIn = Curves.elasticIn;static const ElasticInOutCurve elasticInOut = Curves.elasticInOut;static const ElasticOutCurve elasticOut = Curves.elasticOut;static const Cubic fastLinearToSlowEaseIn = Curves.fastLinearToSlowEaseIn;static const Cubic fastOutSlowIn = Curves.fastOutSlowIn;static const Curve linear = Curves.linear;static const Cubic linearToEaseOut = Curves.linearToEaseOut;static const Cubic slowMiddle = Curves.slowMiddle;<ElevationInfo>[ElevationInfo(0, 0.0, 0, []), ElevationInfo(1, 1.0, 5, <BoxShadow>[]), ElevationInfo(2, 3.0, 8, <BoxShadow>[]), ElevationInfo(3, 6.0, 11, <BoxShadow>[]), Elevat…
+ static const List<ElevationInfo> elevations = <ElevationInfo>[
+ ElevationInfo(0, 0.0, 0, []),
+ ElevationInfo(1, 1.0, 5, <BoxShadow>[
+ // BoxShadow(
+ // blurRadius: 2,
+ // spreadRadius: 0,
+ // offset: Offset(0, 1),
+ // color: ElementColor.mdRefPaletteBlackA30,
+ // ),
+ // BoxShadow(
+ // blurRadius: 3,
+ // spreadRadius: 1,
+ // offset: Offset(0, 1),
+ // color: ElementColor.mdRefPaletteBlackA15,
+ // ),
+ ]),
+ ElevationInfo(2, 3.0, 8, <BoxShadow>[
+ // BoxShadow(
+ // blurRadius: 2,
+ // spreadRadius: 0,
+ // offset: Offset(0, 1),
+ // color: ElementColor.mdRefPaletteBlackA30,
+ // ),
+ // BoxShadow(
+ // blurRadius: 6,
+ // spreadRadius: 2,
+ // offset: Offset(0, 2),
+ // color: ElementColor.mdRefPaletteBlackA15,
+ // ),
+ ]),
+ ElevationInfo(3, 6.0, 11, <BoxShadow>[
+ // BoxShadow(
+ // blurRadius: 3,
+ // spreadRadius: 0,
+ // offset: Offset(0, 1),
+ // color: ElementColor.mdRefPaletteBlackA30,
+ // ),
+ // BoxShadow(
+ // blurRadius: 8,
+ // spreadRadius: 3,
+ // offset: Offset(0, 4),
+ // color: ElementColor.mdRefPaletteBlackA15,
+ // ),
+ ]),
+ ElevationInfo(4, 8.0, 12, <BoxShadow>[
+ // BoxShadow(
+ // blurRadius: 3,
+ // spreadRadius: 0,
+ // offset: Offset(0, 2),
+ // color: ElementColor.mdRefPaletteBlackA30,
+ // ),
+ // BoxShadow(
+ // blurRadius: 10,
+ // spreadRadius: 4,
+ // offset: Offset(0, 6),
+ // color: ElementColor.mdRefPaletteBlackA15,
+ // ),
+ ]),
+ ElevationInfo(5, 12.0, 14, <BoxShadow>[
+ // BoxShadow(
+ // blurRadius: 4,
+ // spreadRadius: 0,
+ // offset: Offset(0, 4),
+ // color: ElementColor.mdRefPaletteBlackA30,
+ // ),
+ // BoxShadow(
+ // blurRadius: 12,
+ // spreadRadius: 6,
+ // offset: Offset(0, 8),
+ // color: ElementColor.mdRefPaletteBlackA15,
+ // ),
+ ]),
+];16 + .0
+ 14 + .0
+ 12 + .0
+ 57 + .0
+ 45 + .0
+ 36 + .0
+ 32 + .0
+ 28 + .0
+ 24 + .0
+ 14 + .0
+ 12 + .0
+ 11 + .0
+ 22 + .0
+ 16 + .0
+ 14 + .0
+ static const bodyLarge = 16 + .0;static const bodyMedium = 14 + .0;static const bodySmall = 12 + .0;static const displayLarge = 57 + .0;static const displayMedium = 45 + .0;static const displaySmall = 36 + .0;static const headlineLarge = 32 + .0;static const headlineMedium = 28 + .0;static const headlineSmall = 24 + .0;static const labelLarge = 14 + .0;static const labelMedium = 12 + .0;static const labelSmall = 11 + .0;static const titleLarge = 22 + .0;static const titleMedium = 16 + .0;static const titleSmall = 14 + .0;Namespace for Default UnselfStyle Font Weights
+w900
+
+
+ FontWeight.w900
+ w700
+
+
+ FontWeight.w700
+ w800
+
+
+ FontWeight.w800
+ w200
+
+
+ FontWeight.w200
+ w300
+
+
+ FontWeight.w300
+ w500
+
+
+ FontWeight.w500
+ w400
+
+
+ FontWeight.w400
+ w600
+
+
+ FontWeight.w600
+ w100
+
+
+ FontWeight.w100
+ FontWeight value of w900
static const FontWeight black = FontWeight.w900;FontWeight value of w700
static const FontWeight bold = FontWeight.w700;FontWeight value of w800
static const FontWeight extraBold = FontWeight.w800;FontWeight value of w200
static const FontWeight extraLight = FontWeight.w200;FontWeight value of w300
static const FontWeight light = FontWeight.w300;FontWeight value of w500
static const FontWeight medium = FontWeight.w500;FontWeight value of w400
static const FontWeight regular = FontWeight.w400;FontWeight value of w600
static const FontWeight semiBold = FontWeight.w600;FontWeight value of w100
static const FontWeight thin = FontWeight.w100;Gaimon.error
+ Gaimon.heavy
+ Gaimon.light
+ Gaimon.medium
+ Gaimon.rigid
+ Gaimon.selection
+ Gaimon.soft
+ Gaimon.success
+ Gaimon.warning
+ static const error = Gaimon.error;static const heavy = Gaimon.heavy;static const light = Gaimon.light;static const medium = Gaimon.medium;static const rigid = Gaimon.rigid;static const select = Gaimon.selection;static const soft = Gaimon.soft;static const success = Gaimon.success;static const warn = Gaimon.warning;0
+ 2
+ 4
+ 8
+ 12
+ 16
+ 20
+ 24
+ 28
+ 32
+ 36
+ 40
+ 48
+ 56
+ 64
+ 96
+ 128
+ static const size00 = 0;static const size01 = 2;static const size02 = 4;static const size03 = 8;static const size04 = 12;static const size05 = 16;static const size06 = 20;static const size07 = 24;static const size08 = 28;static const size09 = 32;static const size10 = 36;static const size11 = 40;static const size12 = 48;static const size13 = 56;static const size14 = 64;static const size15 = 96;static const size16 = 128;static const Full = UnSizes.size11 + .0;static const L = UnSizes.size07 + .0;static const M = UnSizes.size05 + .0;static const None = UnSizes.size00 + .0;static const S = UnSizes.size03 + .0;UnSizes.size11 + .0
+ UnSizes.size07 + .0
+ UnSizes.size05 + .0
+ UnSizes.size00 + .0
+ UnSizes.size03 + .0
+ UnSizes.size09 + .0
+ UnSizes.size01 + .0
+ static const XL = UnSizes.size09 + .0;static const XS = UnSizes.size01 + .0;static const Full = UnSizes.size03 + .0;static const L = UnSizes.size01 + .0;static const M = 1.0;static const None = UnSizes.size00 + .0;static const S = 0.5;UnSizes.size03 + .0
+ UnSizes.size01 + .0
+ 1.0
+ UnSizes.size00 + .0
+ 0.5
+ UnSizes.size02 + .0
+ 0.25
+ static const XL = UnSizes.size02 + .0;static const XS = 0.25;static const Full = 48.0;static const L = 32.0;static const M = 24.0;static const None = 12.0;static const S = 20.0;TextStyle(fontSize: L, height: 1)
+ TextStyle(fontSize: M, height: 1)
+ TextStyle(fontSize: XL, height: 1)
+ 48.0
+ 32.0
+ 24.0
+ 12.0
+ 20.0
+ 48.0
+ 16.0
+ static const XL = 48.0;static const XS = 16.0;static const emojiL = TextStyle(fontSize: L, height: 1);static const emojiM = TextStyle(fontSize: M, height: 1);static const emojiXL = TextStyle(fontSize: XL, height: 1);FluentIcons.add_24_regular
+ FluentIcons.add_circle_24_regular
+ FluentIcons.add_circle_24_filled
+ FluentIcons.add_24_filled
+ FluentIcons.grid_24_regular
+ FluentIcons.grid_24_filled
+ FluentIcons.book_open_24_regular
+ FluentIcons.book_open_24_filled
+ FluentIcons.arrow_down_24_regular
+ FluentIcons.arrow_down_left_24_regular
+ FluentIcons.arrow_left_24_regular
+ FluentIcons.arrow_right_24_regular
+ FluentIcons.arrow_up_24_regular
+ FluentIcons.arrow_bidirectional_up_down_24_regular
+ FluentIcons.arrow_up_left_24_regular
+ FluentIcons.arrow_up_right_24_regular
+ FluentIcons.checkmark_24_regular
+ FluentIcons.checkmark_24_filled
+ chevronLeft
+ chevronCircleLeft
+ chevronCircleLeftFilled
+ FluentIcons.chevron_circle_down_24_regular
+ FluentIcons.chevron_circle_down_24_filled
+ chevronCircleRight
+ chevronCircleRightFilled
+ FluentIcons.chevron_circle_left_24_regular
+ FluentIcons.chevron_circle_left_24_filled
+ FluentIcons.chevron_circle_right_24_regular
+ FluentIcons.chevron_circle_right_24_filled
+ FluentIcons.chevron_circle_up_24_regular
+ FluentIcons.chevron_circle_up_24_filled
+ FluentIcons.chevron_down_24_regular
+ chevronRight
+ FluentIcons.chevron_left_24_regular
+ FluentIcons.chevron_right_24_regular
+ FluentIcons.chevron_up_24_regular
+ FluentIcons.delete_24_regular
+ FluentIcons.delete_24_filled
+ FluentIcons.dismiss_24_regular
+ FluentIcons.dismiss_circle_24_regular
+ FluentIcons.dismiss_circle_24_filled
+ FluentIcons.dismiss_24_filled
+ FluentIcons.edit_24_regular
+ FluentIcons.edit_24_filled
+ FluentIcons.home_24_regular
+ FluentIcons.home_24_filled
+ FluentIcons.list_24_regular
+ FluentIcons.list_24_filled
+ FluentIcons.more_vertical_24_regular
+ FluentIcons.more_vertical_24_filled
+ FluentIcons.note_24_regular
+ FluentIcons.note_24_filled
+ FluentIcons.person_24_regular
+ FluentIcons.person_24_filled
+ FluentIcons.search_24_regular
+ FluentIcons.search_24_filled
+ FluentIcons.settings_24_regular
+ FluentIcons.settings_24_filled
+ FluentIcons.shapes_24_regular
+ FluentIcons.shapes_24_filled
+ FluentIcons.style_guide_24_regular
+ FluentIcons.style_guide_24_filled
+ FluentIcons.brightness_high_24_regular
+ FluentIcons.brightness_low_24_regular
+ FluentIcons.text_effects_24_regular
+ FluentIcons.text_effects_24_filled
+ FluentIcons.weather_sunny_24_regular
+ FluentIcons.weather_sunny_24_filled
+ static const IconData add = FluentIcons.add_24_regular;static const IconData addCircle = FluentIcons.add_circle_24_regular;static const IconData addCircleFilled = FluentIcons.add_circle_24_filled;static const IconData addFilled = FluentIcons.add_24_filled;static const IconData apps = FluentIcons.grid_24_regular;static const IconData appsFilled = FluentIcons.grid_24_filled;static const IconData bookOpen = FluentIcons.book_open_24_regular;static const IconData bookOpenFilled = FluentIcons.book_open_24_filled;static const IconData brandArrowDown = FluentIcons.arrow_down_24_regular;static const IconData brandArrowDownLeft =
+ FluentIcons.arrow_down_left_24_regular;static const IconData brandArrowLeft = FluentIcons.arrow_left_24_regular;static const IconData brandArrowRight = FluentIcons.arrow_right_24_regular;static const IconData brandArrowUp = FluentIcons.arrow_up_24_regular;static const IconData brandArrowUpDown =
+ FluentIcons.arrow_bidirectional_up_down_24_regular;static const IconData brandArrowUpLeft = FluentIcons.arrow_up_left_24_regular;static const IconData brandArrowUpRight =
+ FluentIcons.arrow_up_right_24_regular;static const IconData checkmark = FluentIcons.checkmark_24_regular;static const IconData checkmarkFilled = FluentIcons.checkmark_24_filled;static const IconData chevronBack = chevronLeft;static const IconData chevronCircleBack = chevronCircleLeft;static const IconData chevronCircleBackFilled = chevronCircleLeftFilled;static const IconData chevronCircleDown =
+ FluentIcons.chevron_circle_down_24_regular;static const IconData chevronCircleDownFilled =
+ FluentIcons.chevron_circle_down_24_filled;static const IconData chevronCircleForward = chevronCircleRight;static const IconData chevronCircleForwardFilled = chevronCircleRightFilled;static const IconData chevronCircleLeft =
+ FluentIcons.chevron_circle_left_24_regular;static const IconData chevronCircleLeftFilled =
+ FluentIcons.chevron_circle_left_24_filled;static const IconData chevronCircleRight =
+ FluentIcons.chevron_circle_right_24_regular;static const IconData chevronCircleRightFilled =
+ FluentIcons.chevron_circle_right_24_filled;static const IconData chevronCircleUp =
+ FluentIcons.chevron_circle_up_24_regular;static const IconData chevronCircleUpFilled =
+ FluentIcons.chevron_circle_up_24_filled;static const IconData chevronDown = FluentIcons.chevron_down_24_regular;static const IconData chevronForward = chevronRight;static const IconData chevronLeft = FluentIcons.chevron_left_24_regular;static const IconData chevronRight = FluentIcons.chevron_right_24_regular;static const IconData chevronUp = FluentIcons.chevron_up_24_regular;static const IconData delete = FluentIcons.delete_24_regular;static const IconData deleteFilled = FluentIcons.delete_24_filled;static const IconData dismiss = FluentIcons.dismiss_24_regular;static const IconData dismissCircle = FluentIcons.dismiss_circle_24_regular;static const IconData dismissCircleFilled =
+ FluentIcons.dismiss_circle_24_filled;static const IconData dismissFilled = FluentIcons.dismiss_24_filled;static const IconData edit = FluentIcons.edit_24_regular;static const IconData editFilled = FluentIcons.edit_24_filled;static const IconData home = FluentIcons.home_24_regular;static const IconData homeFilled = FluentIcons.home_24_filled;static const IconData list = FluentIcons.list_24_regular;static const IconData listFilled = FluentIcons.list_24_filled;static const IconData moreVertical = FluentIcons.more_vertical_24_regular;static const IconData moreVerticalFilled =
+ FluentIcons.more_vertical_24_filled;static const IconData note = FluentIcons.note_24_regular;static const IconData noteFilled = FluentIcons.note_24_filled;static const IconData person = FluentIcons.person_24_regular;static const IconData personFilled = FluentIcons.person_24_filled;static const IconData search = FluentIcons.search_24_regular;static const IconData searchFilled = FluentIcons.search_24_filled;static const IconData settings = FluentIcons.settings_24_regular;static const IconData settingsFilled = FluentIcons.settings_24_filled;static const IconData shapes = FluentIcons.shapes_24_regular;static const IconData shapesFilled = FluentIcons.shapes_24_filled;static const IconData style = FluentIcons.style_guide_24_regular;static const IconData styleFilled = FluentIcons.style_guide_24_filled;static const IconData sunMax = FluentIcons.brightness_high_24_regular;static const IconData sunMin = FluentIcons.brightness_low_24_regular;static const IconData textEffects = FluentIcons.text_effects_24_regular;static const IconData textEffectsFilled = FluentIcons.text_effects_24_filled;static const IconData today = FluentIcons.weather_sunny_24_regular;static const IconData todayFilled = FluentIcons.weather_sunny_24_filled;UnselfStyle Text Style Definitions
+Body Large Text Style
+static TextStyle get bodyLarge => _baseTextStyle.copyWith(
+ fontSize: UnFontSizes.bodyLarge,
+ fontWeight: UnFontWeight.regular,
+ );Body Medium Text Style
+static TextStyle get bodyMedium => _baseTextStyle.copyWith(
+ fontSize: UnFontSizes.bodyMedium,
+ fontWeight: UnFontWeight.regular,
+ );Body Small Text Style
+static TextStyle get bodySmall => _baseTextStyle.copyWith(
+ fontSize: UnFontSizes.bodySmall,
+ fontWeight: UnFontWeight.regular,
+ );Display Large Text Style
+static TextStyle get displayLarge => _brandTextStyle.copyWith(
+ fontSize: UnFontSizes.displayLarge,
+ fontWeight: UnFontWeight.regular,
+ );Display Medium Text Style
+static TextStyle get displayMedium => _brandTextStyle.copyWith(
+ fontSize: UnFontSizes.displayMedium,
+ fontWeight: UnFontWeight.regular,
+ );Display Small Text Style
+static TextStyle get displaySmall => _brandTextStyle.copyWith(
+ fontSize: UnFontSizes.displaySmall,
+ fontWeight: UnFontWeight.regular,
+ );Headline Large Text Style
+static TextStyle get headlineLarge => _brandTextStyle.copyWith(
+ fontSize: UnFontSizes.headlineLarge,
+ fontWeight: UnFontWeight.regular,
+ );Headline Medium Text Style
+static TextStyle get headlineMedium => _brandTextStyle.copyWith(
+ fontSize: UnFontSizes.headlineMedium,
+ fontWeight: UnFontWeight.regular,
+ );Headline Small Text Style
+static TextStyle get headlineSmall => _brandTextStyle.copyWith(
+ fontSize: UnFontSizes.headlineSmall,
+ fontWeight: UnFontWeight.regular,
+ );Label Large Text Style
+static TextStyle get labelLarge => _baseTextStyle.copyWith(
+ fontSize: UnFontSizes.labelLarge,
+ fontWeight: UnFontWeight.medium,
+ );Label Medium Text Style
+static TextStyle get labelMedium => _baseTextStyle.copyWith(
+ fontSize: UnFontSizes.labelMedium,
+ fontWeight: UnFontWeight.medium,
+ );Label Small Text Style
+static TextStyle get labelSmall => _baseTextStyle.copyWith(
+ fontSize: UnFontSizes.labelSmall,
+ fontWeight: UnFontWeight.medium,
+ );Title Large Text Style
+static TextStyle get titleLarge => _brandTextStyle.copyWith(
+ fontSize: UnFontSizes.titleLarge,
+ fontWeight: UnFontWeight.regular,
+ );Title Medium Text Style
+static TextStyle get titleMedium => _baseTextStyle.copyWith(
+ fontSize: UnFontSizes.titleMedium,
+ fontWeight: UnFontWeight.medium,
+ );Title Small Text Style
+static TextStyle get titleSmall => _baseTextStyle.copyWith(
+ fontSize: UnFontSizes.titleSmall,
+ fontWeight: UnFontWeight.medium,
+ );TextTheme for for large screens.
static TextTheme get largeText => TextTheme(
+ displayLarge: _.displayLarge._large,
+ displayMedium: _.displayMedium._large,
+ displaySmall: _.displaySmall._large,
+ headlineLarge: _.headlineLarge._large,
+ headlineMedium: _.headlineMedium._large,
+ headlineSmall: _.headlineSmall._large,
+ titleLarge: _.titleLarge._large,
+ titleMedium: _.titleMedium._large,
+ titleSmall: _.titleSmall._large,
+ bodyLarge: _.bodyLarge._large,
+ bodyMedium: _.bodyMedium._large,
+ bodySmall: _.bodySmall._large,
+ labelLarge: _.labelLarge._large,
+ labelMedium: _.labelMedium._large,
+ labelSmall: _.labelSmall._large,
+ );TextTheme for for medium screens.
static TextTheme get mediumText => TextTheme(
+ displayLarge: _.displayLarge,
+ displayMedium: _.displayMedium,
+ displaySmall: _.displaySmall,
+ headlineLarge: _.headlineLarge,
+ headlineMedium: _.headlineMedium,
+ headlineSmall: _.headlineSmall,
+ titleLarge: _.titleLarge,
+ titleMedium: _.titleMedium,
+ titleSmall: _.titleSmall,
+ bodyLarge: _.bodyLarge,
+ bodyMedium: _.bodyMedium,
+ bodySmall: _.bodySmall,
+ labelLarge: _.labelLarge,
+ labelMedium: _.labelMedium,
+ labelSmall: _.labelSmall,
+ );TextTheme for for small screens.
static TextTheme get smallText => TextTheme(
+ displayLarge: _.displayLarge._small,
+ displayMedium: _.displayMedium._small,
+ displaySmall: _.displaySmall._small,
+ headlineLarge: _.headlineLarge._small,
+ headlineMedium: _.headlineMedium._small,
+ headlineSmall: _.headlineSmall._small,
+ titleLarge: _.titleLarge._small,
+ titleMedium: _.titleMedium._small,
+ titleSmall: _.titleSmall._small,
+ bodyLarge: _.bodyLarge._small,
+ bodyMedium: _.bodyMedium._small,
+ bodySmall: _.bodySmall._small,
+ labelLarge: _.labelLarge._small,
+ labelMedium: _.labelMedium._small,
+ labelSmall: _.labelSmall._small,
+ );static get dark =>
+ defaultTheme.copyWith(colorScheme: UnColorTheme.darkColorStyle);static get defaultTheme => ThemeData(
+ useMaterial3: true,
+ textTheme: UnTextTheme.mediumText,
+ extensions: const [UnColorTheme.lightCustomColors],
+ );static get light =>
+ defaultTheme.copyWith(colorScheme: UnColorTheme.lightColorStyle);static SmoothRadius screenCornerRadius(BuildContext context) => SmoothRadius(
+ cornerRadius: MediaQuery.of(context).padding.top / 2,
+ cornerSmoothing: UnCorner.smoothFactor,
+ );const ButtonAction({
+ super.key,
+ required this.action,
+ required this.onPressed,
+});DiagnosticsNode objects describing this node's
+children.
+ final String action;Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ ColorScheme colorScheme = Theme.of(context).colorScheme;
+ TextTheme textTheme = Theme.of(context).textTheme;
+
+ return Padding(
+ padding: const EdgeInsets.all(UnSpaces.S),
+ child: FloatingActionButton.extended(
+ elevation: 3,
+ focusElevation: 1,
+ foregroundColor: colorScheme.onPrimary,
+ backgroundColor: colorScheme.primary,
+ shape: RoundedRectangleBorder(
+ borderRadius: BorderRadius.circular(100),
+ ),
+ onPressed: () {
+ UnHaptics.select();
+ onPressed?.call();
+ },
+ label: Text(
+ action.toUpperCase(),
+ style: textTheme.labelLarge?.copyWith(
+ color: colorScheme.onPrimary,
+ letterSpacing: 1.0,
+ ),
+ ),
+ ),
+ );
+}final void Function()? onPressed;ButtonBackground(this.primary, this.onSurface);T that depends on states.
+ final Color? onSurface;final Color? primary;Returns a value of type T that depends on states.
Widgets like TextButton and ElevatedButton apply this method to their +current MaterialStates to compute colors and other visual parameters +at build time.
+@override
+Color? resolve(Set<MaterialState> states) {
+ if (states.contains(MaterialState.disabled)) {
+ return onSurface?.withOpacity(0.12);
+ }
+
+ return primary;
+}factory ButtonElevated.icon({
+ Key? key,
+ VoidCallback? onPressed,
+ VoidCallback? onLongPress,
+ ValueChanged<bool>? onHover,
+ ValueChanged<bool>? onFocusChange,
+ ButtonStyle? style,
+ FocusNode? focusNode,
+ bool? autofocus,
+ Clip? clipBehavior,
+ required Widget icon,
+ required Widget label,
+}) {
+ return ButtonElevated(
+ key: key,
+ onPressed: onPressed,
+ onLongPress: onLongPress,
+ onHover: onHover,
+ onFocusChange: onFocusChange,
+ style: style,
+ focusNode: focusNode,
+ autofocus: autofocus ?? false,
+ clipBehavior: clipBehavior ?? Clip.none,
+ child: ButtonIcon(
+ icon: icon,
+ label: label,
+ ),
+ );
+}DiagnosticsNode objects describing this node's
+children.
+ Defines the button's default appearance.
+The button child's Text and Icon widgets are rendered with +the ButtonStyle's foreground color. The button's InkWell adds +the style's overlay color when the button is focused, hovered +or pressed. The button's background color becomes its Material +color.
+All of the ButtonStyle's defaults appear below. In this list
+"Theme.foo" is shorthand for Theme.of(context).foo. Color
+scheme values like "onSurface(0.38)" are shorthand for
+onSurface.withOpacity(0.38). MaterialStateProperty valued
+properties that are not followed by a sublist have the same
+value for all states, otherwise the values are as specified for
+each state, and "others" means all other states.
The textScaleFactor is the value of
+MediaQuery.of(context).textScaleFactor and the names of the
+EdgeInsets constructors and EdgeInsetsGeometry.lerp have been
+abbreviated for readability.
The color of the ButtonStyle.textStyle is not used, the +ButtonStyle.foregroundColor color is used instead.
+textStyle - Theme.textTheme.buttonbackgroundColor
+foregroundColor
+overlayColor
+shadowColor - Theme.shadowColorelevation
+padding
+textScaleFactor <= 1 - horizontal(16)1 < textScaleFactor <= 2 - lerp(horizontal(16), horizontal(8))2 < textScaleFactor <= 3 - lerp(horizontal(8), horizontal(4))3 < textScaleFactor - horizontal(4)minimumSize - Size(64, 36)fixedSize - nullmaximumSize - Size.infiniteside - nullshape - RoundedRectangleBorder(borderRadius: BorderRadius.circular(4))mouseCursor
+visualDensity - theme.visualDensitytapTargetSize - theme.materialTapTargetSizeanimationDuration - kThemeChangeDurationenableFeedback - truealignment - Alignment.centersplashFactory - InkRipple.splashFactoryThe default padding values for the ElevatedButton.icon factory are slightly different:
+padding
+textScaleFactor <= 1 - start(12) end(16)1 < textScaleFactor <= 2 - lerp(start(12) end(16), horizontal(8))2 < textScaleFactor <= 3 - lerp(horizontal(8), horizontal(4))3 < textScaleFactor - horizontal(4)The default value for side, which defines the appearance of the button's
+outline, is null. That means that the outline is defined by the button
+shape's OutlinedBorder.side. Typically the default value of an
+OutlinedBorder's side is BorderSide.none, so an outline is not drawn.
If ThemeData.useMaterial3 is set to true the following defaults will +be used:
+textStyle - Theme.textTheme.labelLargebackgroundColor
+foregroundColor
+overlayColor
+shadowColor - Theme.colorScheme.shadowsurfaceTintColor - Theme.colorScheme.surfaceTintelevation
+padding
+textScaleFactor <= 1 - horizontal(16)1 < textScaleFactor <= 2 - lerp(horizontal(16), horizontal(8))2 < textScaleFactor <= 3 - lerp(horizontal(8), horizontal(4))3 < textScaleFactor - horizontal(4)minimumSize - Size(64, 40)fixedSize - nullmaximumSize - Size.infiniteside - nullshape - StadiumBorder()mouseCursor
+visualDensity - Theme.visualDensitytapTargetSize - Theme.materialTapTargetSizeanimationDuration - kThemeChangeDurationenableFeedback - truealignment - Alignment.centersplashFactory - Theme.splashFactory@override
+ButtonStyle defaultStyleOf(BuildContext context) {
+ return super
+ .defaultStyleOf(
+ context,
+ )
+ .copyWith(
+ // elevation: ButtonStyleButton.allOrNull(.0),
+ backgroundColor: ButtonBackground(
+ Theme.of(context).colorScheme.surface,
+ Theme.of(context).colorScheme.onSurface,
+ ),
+ shadowColor: MaterialStateProperty.all(
+ Theme.of(context).colorScheme.shadow,
+ ),
+ foregroundColor: ButtonForeground(
+ Theme.of(context).colorScheme.primary,
+ Theme.of(context).colorScheme.onSurface,
+ ),
+ overlayColor: ButtonOverlay(
+ Theme.of(context).colorScheme.primary,
+ ),
+ );
+}ButtonElevation(this.elevation);T that depends on states.
+ final double elevation;Returns a value of type T that depends on states.
Widgets like TextButton and ElevatedButton apply this method to their +current MaterialStates to compute colors and other visual parameters +at build time.
+@override
+double resolve(Set<MaterialState> states) {
+ if (states.contains(MaterialState.disabled)) return 0;
+ if (states.contains(MaterialState.hovered)) return elevation + 2;
+ if (states.contains(MaterialState.focused)) return elevation + 2;
+ if (states.contains(MaterialState.pressed)) return elevation + 6;
+
+ return elevation;
+}const ButtonFilled({
+ Key? key,
+ VoidCallback? onPressed,
+ VoidCallback? onLongPress,
+ ValueChanged<bool>? onHover,
+ ValueChanged<bool>? onFocusChange,
+ ButtonStyle? style,
+ FocusNode? focusNode,
+ bool autofocus = false,
+ Clip clipBehavior = Clip.none,
+ required Widget? child,
+}) : super(
+ key: key,
+ onPressed: onPressed,
+ onLongPress: onLongPress,
+ onHover: onHover,
+ onFocusChange: onFocusChange,
+ style: style,
+ focusNode: focusNode,
+ autofocus: autofocus,
+ clipBehavior: clipBehavior,
+ child: child,
+ );DiagnosticsNode objects describing this node's
+children.
+ Defines the button's default appearance.
+The button child's Text and Icon widgets are rendered with +the ButtonStyle's foreground color. The button's InkWell adds +the style's overlay color when the button is focused, hovered +or pressed. The button's background color becomes its Material +color.
+All of the ButtonStyle's defaults appear below. In this list
+"Theme.foo" is shorthand for Theme.of(context).foo. Color
+scheme values like "onSurface(0.38)" are shorthand for
+onSurface.withOpacity(0.38). MaterialStateProperty valued
+properties that are not followed by a sublist have the same
+value for all states, otherwise the values are as specified for
+each state, and "others" means all other states.
The textScaleFactor is the value of
+MediaQuery.of(context).textScaleFactor and the names of the
+EdgeInsets constructors and EdgeInsetsGeometry.lerp have been
+abbreviated for readability.
The color of the ButtonStyle.textStyle is not used, the +ButtonStyle.foregroundColor color is used instead.
+textStyle - Theme.textTheme.buttonbackgroundColor
+foregroundColor
+overlayColor
+shadowColor - Theme.shadowColorelevation
+padding
+textScaleFactor <= 1 - horizontal(16)1 < textScaleFactor <= 2 - lerp(horizontal(16), horizontal(8))2 < textScaleFactor <= 3 - lerp(horizontal(8), horizontal(4))3 < textScaleFactor - horizontal(4)minimumSize - Size(64, 36)fixedSize - nullmaximumSize - Size.infiniteside - nullshape - RoundedRectangleBorder(borderRadius: BorderRadius.circular(4))mouseCursor
+visualDensity - theme.visualDensitytapTargetSize - theme.materialTapTargetSizeanimationDuration - kThemeChangeDurationenableFeedback - truealignment - Alignment.centersplashFactory - InkRipple.splashFactoryThe default padding values for the ElevatedButton.icon factory are slightly different:
+padding
+textScaleFactor <= 1 - start(12) end(16)1 < textScaleFactor <= 2 - lerp(start(12) end(16), horizontal(8))2 < textScaleFactor <= 3 - lerp(horizontal(8), horizontal(4))3 < textScaleFactor - horizontal(4)The default value for side, which defines the appearance of the button's
+outline, is null. That means that the outline is defined by the button
+shape's OutlinedBorder.side. Typically the default value of an
+OutlinedBorder's side is BorderSide.none, so an outline is not drawn.
If ThemeData.useMaterial3 is set to true the following defaults will +be used:
+textStyle - Theme.textTheme.labelLargebackgroundColor
+foregroundColor
+overlayColor
+shadowColor - Theme.colorScheme.shadowsurfaceTintColor - Theme.colorScheme.surfaceTintelevation
+padding
+textScaleFactor <= 1 - horizontal(16)1 < textScaleFactor <= 2 - lerp(horizontal(16), horizontal(8))2 < textScaleFactor <= 3 - lerp(horizontal(8), horizontal(4))3 < textScaleFactor - horizontal(4)minimumSize - Size(64, 40)fixedSize - nullmaximumSize - Size.infiniteside - nullshape - StadiumBorder()mouseCursor
+visualDensity - Theme.visualDensitytapTargetSize - Theme.materialTapTargetSizeanimationDuration - kThemeChangeDurationenableFeedback - truealignment - Alignment.centersplashFactory - Theme.splashFactory@override
+ButtonStyle defaultStyleOf(BuildContext context) {
+ return super
+ .defaultStyleOf(
+ context,
+ )
+ .copyWith(
+ elevation: ButtonStyleButton.allOrNull(.0),
+ backgroundColor: ButtonBackground(
+ Theme.of(context).colorScheme.primary,
+ Theme.of(context).colorScheme.onBackground,
+ ),
+ foregroundColor: ButtonForeground(
+ Theme.of(context).colorScheme.onPrimary,
+ Theme.of(context).colorScheme.onSurface,
+ ),
+ overlayColor: ButtonOverlay(
+ Theme.of(context).colorScheme.onPrimary,
+ ),
+ );
+}ButtonForeground(this.onPrimary, this.onSurface);T that depends on states.
+ final Color? onPrimary;final Color? onSurface;Returns a value of type T that depends on states.
Widgets like TextButton and ElevatedButton apply this method to their +current MaterialStates to compute colors and other visual parameters +at build time.
+@override
+Color? resolve(Set<MaterialState> states) {
+ if (states.contains(MaterialState.disabled)) {
+ return onSurface?.withOpacity(0.38);
+ }
+
+ return onPrimary;
+}const ButtonIcon({
+ Key? key,
+ required this.label,
+ required this.icon,
+}) : super(key: key);DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ final double scale = MediaQuery.maybeOf(context)?.textScaleFactor ?? 1;
+ final double gap =
+ scale <= 1 ? 8 : lerpDouble(8, 4, math.min(scale - 1, 1))!;
+
+ return Row(
+ mainAxisSize: MainAxisSize.min,
+ children: <Widget>[icon, SizedBox(width: gap), Flexible(child: label)],
+ );
+}final Widget icon;final Widget label;factory ButtonOutlined.icon({
+ Key? key,
+ VoidCallback? onPressed,
+ VoidCallback? onLongPress,
+ ValueChanged<bool>? onHover,
+ ValueChanged<bool>? onFocusChange,
+ ButtonStyle? style,
+ FocusNode? focusNode,
+ bool? autofocus,
+ Clip? clipBehavior,
+ required Widget icon,
+ required Widget label,
+}) {
+ return ButtonOutlined(
+ key: key,
+ onPressed: onPressed,
+ onLongPress: onLongPress,
+ onHover: onHover,
+ onFocusChange: onFocusChange,
+ style: style,
+ focusNode: focusNode,
+ autofocus: autofocus ?? false,
+ clipBehavior: clipBehavior ?? Clip.none,
+ child: ButtonIcon(
+ icon: icon,
+ label: label,
+ ),
+ );
+}DiagnosticsNode objects describing this node's
+children.
+ Defines the button's default appearance.
+With the exception of ButtonStyle.side, which defines the +outline, and ButtonStyle.padding, the returned style is the +same as for TextButton.
+The button child's Text and Icon widgets are rendered with +the ButtonStyle's foreground color. The button's InkWell adds +the style's overlay color when the button is focused, hovered +or pressed. The button's background color becomes its Material +color and is transparent by default.
+All of the ButtonStyle's defaults appear below. In this list
+"Theme.foo" is shorthand for Theme.of(context).foo. Color
+scheme values like "onSurface(0.38)" are shorthand for
+onSurface.withOpacity(0.38). MaterialStateProperty valued
+properties that are not followed by a sublist have the same
+value for all states, otherwise the values are as specified for
+each state and "others" means all other states.
The color of the ButtonStyle.textStyle is not used, the +ButtonStyle.foregroundColor is used instead.
+textStyle - Theme.textTheme.buttonbackgroundColor - transparentforegroundColor
+overlayColor
+shadowColor - Theme.shadowColorelevation - 0padding
+textScaleFactor <= 1 - horizontal(16)1 < textScaleFactor <= 2 - lerp(horizontal(16), horizontal(8))2 < textScaleFactor <= 3 - lerp(horizontal(8), horizontal(4))3 < textScaleFactor - horizontal(4)minimumSize - Size(64, 36)fixedSize - nullmaximumSize - Size.infiniteside - BorderSide(width: 1, color: Theme.colorScheme.onSurface(0.12))shape - RoundedRectangleBorder(borderRadius: BorderRadius.circular(4))mouseCursor
+visualDensity - theme.visualDensitytapTargetSize - theme.materialTapTargetSizeanimationDuration - kThemeChangeDurationenableFeedback - truealignment - Alignment.centersplashFactory - InkRipple.splashFactoryIf ThemeData.useMaterial3 is set to true the following defaults will +be used:
+textStyle - Theme.textTheme.labelLargebackgroundColor - transparentforegroundColor
+overlayColor
+shadowColor - nullsurfaceTintColor - nullelevation - 0padding
+textScaleFactor <= 1 - horizontal(16)1 < textScaleFactor <= 2 - lerp(horizontal(16), horizontal(8))2 < textScaleFactor <= 3 - lerp(horizontal(8), horizontal(4))3 < textScaleFactor - horizontal(4)minimumSize - Size(64, 40)fixedSize - nullmaximumSize - Size.infiniteside
+shape - StadiumBorder()mouseCursor
+visualDensity - theme.visualDensitytapTargetSize - theme.materialTapTargetSizeanimationDuration - kThemeChangeDurationenableFeedback - truealignment - Alignment.centersplashFactory - Theme.splashFactory@override
+ButtonStyle defaultStyleOf(BuildContext context) {
+ final colorScheme = Theme.of(context).colorScheme;
+
+ return super
+ .defaultStyleOf(
+ context,
+ )
+ .copyWith(
+ elevation: ButtonStyleButton.allOrNull(.0),
+ foregroundColor: ButtonForeground(
+ Theme.of(context).colorScheme.primary,
+ Theme.of(context).colorScheme.onSurface,
+ ),
+ overlayColor: ButtonOverlay(
+ Theme.of(context).colorScheme.primary,
+ ),
+ splashFactory: kIsWeb ? null : InkSparkle.splashFactory,
+ side: MaterialStateProperty.all(
+ BorderSide(
+ width: UnStroke.L,
+ color: isEnabled
+ ? colorScheme.primary
+ : colorScheme.outline.withOpacity(0.12),
+ ),
+ ),
+ );
+}bool get isEnabled => onPressed != null;ButtonOverlay(this.onPrimary);T that depends on states.
+ final Color onPrimary;Returns a value of type T that depends on states.
Widgets like TextButton and ElevatedButton apply this method to their +current MaterialStates to compute colors and other visual parameters +at build time.
+@override
+Color? resolve(Set<MaterialState> states) {
+ if (states.contains(MaterialState.hovered)) {
+ return onPrimary.withOpacity(0.08);
+ }
+ if (states.contains(MaterialState.focused) ||
+ states.contains(MaterialState.pressed)) {
+ return onPrimary.withOpacity(0.12);
+ }
+
+ return null;
+}factory ButtonText.icon({
+ Key? key,
+ VoidCallback? onPressed,
+ VoidCallback? onLongPress,
+ ValueChanged<bool>? onHover,
+ ValueChanged<bool>? onFocusChange,
+ ButtonStyle? style,
+ FocusNode? focusNode,
+ bool? autofocus,
+ Clip? clipBehavior,
+ required Widget icon,
+ required Widget label,
+}) {
+ return ButtonText(
+ key: key,
+ onPressed: onPressed,
+ onLongPress: onLongPress,
+ onHover: onHover,
+ onFocusChange: onFocusChange,
+ style: style,
+ focusNode: focusNode,
+ autofocus: autofocus ?? false,
+ clipBehavior: clipBehavior ?? Clip.none,
+ child: ButtonIcon(
+ icon: icon,
+ label: label,
+ ),
+ );
+}DiagnosticsNode objects describing this node's
+children.
+ Defines the button's default appearance.
+The button child's Text and Icon widgets are rendered with +the ButtonStyle's foreground color. The button's InkWell adds +the style's overlay color when the button is focused, hovered +or pressed. The button's background color becomes its Material +color and is transparent by default.
+All of the ButtonStyle's defaults appear below.
+In this list "Theme.foo" is shorthand for
+Theme.of(context).foo. Color scheme values like
+"onSurface(0.38)" are shorthand for
+onSurface.withOpacity(0.38). MaterialStateProperty valued
+properties that are not followed by a sublist have the same
+value for all states, otherwise the values are as specified for
+each state and "others" means all other states.
The textScaleFactor is the value of
+MediaQuery.of(context).textScaleFactor and the names of the
+EdgeInsets constructors and EdgeInsetsGeometry.lerp have been
+abbreviated for readability.
The color of the ButtonStyle.textStyle is not used, the +ButtonStyle.foregroundColor color is used instead.
+textStyle - Theme.textTheme.buttonbackgroundColor - transparentforegroundColor
+overlayColor
+shadowColor - Theme.shadowColorelevation - 0padding
+textScaleFactor <= 1 - all(8)1 < textScaleFactor <= 2 - lerp(all(8), horizontal(8))2 < textScaleFactor <= 3 - lerp(horizontal(8), horizontal(4))3 < textScaleFactor - horizontal(4)minimumSize - Size(64, 36)fixedSize - nullmaximumSize - Size.infiniteside - nullshape - RoundedRectangleBorder(borderRadius: BorderRadius.circular(4))mouseCursor
+visualDensity - theme.visualDensitytapTargetSize - theme.materialTapTargetSizeanimationDuration - kThemeChangeDurationenableFeedback - truealignment - Alignment.centersplashFactory - InkRipple.splashFactoryThe default padding values for the TextButton.icon factory are slightly different:
+padding
+textScaleFactor <= 1 - all(8)1 < textScaleFactor <= 2 - lerp(all(8), horizontal(4))2 < textScaleFactor - horizontal(4)The default value for side, which defines the appearance of the button's
+outline, is null. That means that the outline is defined by the button
+shape's OutlinedBorder.side. Typically the default value of an
+OutlinedBorder's side is BorderSide.none, so an outline is not drawn.
If ThemeData.useMaterial3 is set to true the following defaults will +be used:
+textStyle - Theme.textTheme.labelLargebackgroundColor - transparentforegroundColor
+overlayColor
+shadowColor - nullsurfaceTintColor - nullelevation - 0padding
+textScaleFactor <= 1 - all(8)1 < textScaleFactor <= 2 - lerp(all(8), horizontal(8))2 < textScaleFactor <= 3 - lerp(horizontal(8), horizontal(4))3 < textScaleFactor - horizontal(4)minimumSize - Size(64, 40)fixedSize - nullmaximumSize - Size.infiniteside - nullshape - StadiumBorder()mouseCursor
+visualDensity - theme.visualDensitytapTargetSize - theme.materialTapTargetSizeanimationDuration - kThemeChangeDurationenableFeedback - truealignment - Alignment.centersplashFactory - Theme.splashFactory@override
+ButtonStyle defaultStyleOf(BuildContext context) {
+ return super
+ .defaultStyleOf(
+ context,
+ )
+ .copyWith(
+ elevation: ButtonStyleButton.allOrNull(.0),
+ foregroundColor: ButtonForeground(
+ Theme.of(context).colorScheme.primary,
+ Theme.of(context).colorScheme.onSurface,
+ ),
+ overlayColor: ButtonOverlay(
+ Theme.of(context).colorScheme.primary,
+ ),
+ splashFactory: kIsWeb ? null : InkSparkle.splashFactory,
+ );
+}factory ButtonTonal.icon({
+ Key? key,
+ VoidCallback? onPressed,
+ VoidCallback? onLongPress,
+ ValueChanged<bool>? onHover,
+ ValueChanged<bool>? onFocusChange,
+ ButtonStyle? style,
+ FocusNode? focusNode,
+ bool? autofocus,
+ Clip? clipBehavior,
+ required Widget icon,
+ required Widget label,
+}) {
+ return ButtonTonal(
+ key: key,
+ onPressed: onPressed,
+ onLongPress: onLongPress,
+ onHover: onHover,
+ onFocusChange: onFocusChange,
+ style: style,
+ focusNode: focusNode,
+ autofocus: autofocus ?? false,
+ clipBehavior: clipBehavior ?? Clip.none,
+ child: ButtonIcon(
+ icon: icon,
+ label: label,
+ ),
+ );
+}DiagnosticsNode objects describing this node's
+children.
+ Defines the button's default appearance.
+The button child's Text and Icon widgets are rendered with +the ButtonStyle's foreground color. The button's InkWell adds +the style's overlay color when the button is focused, hovered +or pressed. The button's background color becomes its Material +color.
+All of the ButtonStyle's defaults appear below. In this list
+"Theme.foo" is shorthand for Theme.of(context).foo. Color
+scheme values like "onSurface(0.38)" are shorthand for
+onSurface.withOpacity(0.38). MaterialStateProperty valued
+properties that are not followed by a sublist have the same
+value for all states, otherwise the values are as specified for
+each state, and "others" means all other states.
The textScaleFactor is the value of
+MediaQuery.of(context).textScaleFactor and the names of the
+EdgeInsets constructors and EdgeInsetsGeometry.lerp have been
+abbreviated for readability.
The color of the ButtonStyle.textStyle is not used, the +ButtonStyle.foregroundColor color is used instead.
+textStyle - Theme.textTheme.buttonbackgroundColor
+foregroundColor
+overlayColor
+shadowColor - Theme.shadowColorelevation
+padding
+textScaleFactor <= 1 - horizontal(16)1 < textScaleFactor <= 2 - lerp(horizontal(16), horizontal(8))2 < textScaleFactor <= 3 - lerp(horizontal(8), horizontal(4))3 < textScaleFactor - horizontal(4)minimumSize - Size(64, 36)fixedSize - nullmaximumSize - Size.infiniteside - nullshape - RoundedRectangleBorder(borderRadius: BorderRadius.circular(4))mouseCursor
+visualDensity - theme.visualDensitytapTargetSize - theme.materialTapTargetSizeanimationDuration - kThemeChangeDurationenableFeedback - truealignment - Alignment.centersplashFactory - InkRipple.splashFactoryThe default padding values for the ElevatedButton.icon factory are slightly different:
+padding
+textScaleFactor <= 1 - start(12) end(16)1 < textScaleFactor <= 2 - lerp(start(12) end(16), horizontal(8))2 < textScaleFactor <= 3 - lerp(horizontal(8), horizontal(4))3 < textScaleFactor - horizontal(4)The default value for side, which defines the appearance of the button's
+outline, is null. That means that the outline is defined by the button
+shape's OutlinedBorder.side. Typically the default value of an
+OutlinedBorder's side is BorderSide.none, so an outline is not drawn.
If ThemeData.useMaterial3 is set to true the following defaults will +be used:
+textStyle - Theme.textTheme.labelLargebackgroundColor
+foregroundColor
+overlayColor
+shadowColor - Theme.colorScheme.shadowsurfaceTintColor - Theme.colorScheme.surfaceTintelevation
+padding
+textScaleFactor <= 1 - horizontal(16)1 < textScaleFactor <= 2 - lerp(horizontal(16), horizontal(8))2 < textScaleFactor <= 3 - lerp(horizontal(8), horizontal(4))3 < textScaleFactor - horizontal(4)minimumSize - Size(64, 40)fixedSize - nullmaximumSize - Size.infiniteside - nullshape - StadiumBorder()mouseCursor
+visualDensity - Theme.visualDensitytapTargetSize - Theme.materialTapTargetSizeanimationDuration - kThemeChangeDurationenableFeedback - truealignment - Alignment.centersplashFactory - Theme.splashFactory@override
+ButtonStyle defaultStyleOf(BuildContext context) {
+ return super
+ .defaultStyleOf(
+ context,
+ )
+ .copyWith(
+ elevation: ButtonStyleButton.allOrNull(.0),
+ backgroundColor: ButtonBackground(
+ Theme.of(context).colorScheme.secondaryContainer,
+ Theme.of(context).colorScheme.onBackground,
+ ),
+ foregroundColor: ButtonForeground(
+ Theme.of(context).colorScheme.onSecondaryContainer,
+ Theme.of(context).colorScheme.onSurface,
+ ),
+ overlayColor: ButtonOverlay(
+ Theme.of(context).colorScheme.primary,
+ ),
+ );
+}const CardTextEdit({
+ super.key,
+ required this.initialText,
+ required this.onChanged,
+ required this.onTap,
+ this.autoFocus,
+});DiagnosticsNode objects describing this node's
+children.
+ final bool? autoFocus;Creates the mutable state for this widget at a given location in the tree.
+Subclasses should override this method to return a newly created +instance of their associated State subclass:
+@override
+State<SomeWidget> createState() => _SomeWidgetState();
+The framework can call this method multiple times over the lifetime of
+a StatefulWidget. For example, if the widget is inserted into the tree
+in multiple locations, the framework will create a separate State object
+for each location. Similarly, if the widget is removed from the tree and
+later inserted into the tree again, the framework will call createState
+again to create a fresh State object, simplifying the lifecycle of
+State objects.
@override
+State<CardTextEdit> createState() => CardTextEditState();final String? initialText;final ValueChanged<String>? onChanged;final VoidCallback? onTap;Describes the part of the user interface represented by this widget.
+The framework calls this method in a number of different situations. For +example:
+This method can potentially be called in every frame and should not have +any side effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor, the +given BuildContext, and the internal state of this State object.
+The given BuildContext contains information about the location in the
+tree at which this widget is being built. For example, the context
+provides the set of inherited widgets for this location in the tree. The
+BuildContext argument is always the same as the context property of
+this State object and will remain the same for the lifetime of this
+object. The BuildContext argument is provided redundantly here so that
+this method matches the signature for a WidgetBuilder.
Putting a Widget build(BuildContext context) method on State rather
+than putting a Widget build(BuildContext context, State state) method
+on StatefulWidget gives developers more flexibility when subclassing
+StatefulWidget.
For example, AnimatedWidget is a subclass of StatefulWidget that
+introduces an abstract Widget build(BuildContext context) method for its
+subclasses to implement. If StatefulWidget already had a build method
+that took a State argument, AnimatedWidget would be forced to provide
+its State object to subclasses even though its State object is an
+internal implementation detail of AnimatedWidget.
Conceptually, StatelessWidget could also be implemented as a subclass of +StatefulWidget in a similar manner. If the build method were on +StatefulWidget rather than State, that would not be possible anymore.
+Putting the build function on State rather than StatefulWidget also
+helps avoid a category of bugs related to closures implicitly capturing
+this. If you defined a closure in a build function on a
+StatefulWidget, that closure would implicitly capture this, which is
+the current widget instance, and would have the (immutable) fields of that
+instance in scope:
// (this is not valid Flutter code)
+class MyButton extends StatefulWidgetX {
+ MyButton({super.key, required this.color});
+
+ final Color color;
+
+ @override
+ Widget build(BuildContext context, State state) {
+ return SpecialWidget(
+ handler: () { print('color: \$color'); },
+ );
+ }
+}
+For example, suppose the parent builds MyButton with color being blue,
+the \$color in the print function refers to blue, as expected. Now,
+suppose the parent rebuilds MyButton with green. The closure created by
+the first build still implicitly refers to the original widget and the
+\$color still prints blue even through the widget has been updated to
+green; should that closure outlive its widget, it would print outdated
+information.
In contrast, with the build function on the State object, closures +created during build implicitly capture the State instance instead of +the widget instance:
+class MyButton extends StatefulWidget {
+ const MyButton({super.key, this.color = Colors.teal});
+
+ final Color color;
+ // ...
+}
+
+class MyButtonState extends State<MyButton> {
+ // ...
+ @override
+ Widget build(BuildContext context) {
+ return SpecialWidget(
+ handler: () { print('color: \${widget.color}'); },
+ );
+ }
+}
+Now when the parent rebuilds MyButton with green, the closure created by
+the first build still refers to State object, which is preserved across
+rebuilds, but the framework has updated that State object's widget
+property to refer to the new MyButton instance and \${widget.color}
+prints green, as expected.
See also:
+@override
+Widget build(BuildContext context) => TextField(
+ controller: controller,
+ autofocus: widget.autoFocus ?? true,
+ onChanged: widget.onChanged,
+ textAlign: TextAlign.center,
+ textAlignVertical: TextAlignVertical.center,
+ style: Theme.of(context).textTheme.bodyLarge,
+ expands: true,
+ maxLines: null,
+ maxLength: 300,
+ onTap: widget.onTap,
+ decoration: const InputDecoration(
+ hintText: 'Start Writing...',
+ border: InputBorder.none,
+ contentPadding: EdgeInsets.only(
+ top: 16.0,
+ left: 16.0,
+ right: 16.0,
+ bottom: 16.0,
+ ),
+ ),
+ buildCounter: (
+ _, {
+ required currentLength,
+ maxLength,
+ required isFocused,
+ }) =>
+ Container(
+ height: 16,
+ alignment: Alignment.center,
+ child: Text(
+ isFocused ? "\$currentLength / \$maxLength" : "",
+ textAlign: TextAlign.center,
+ style: Theme.of(_).textTheme.labelMedium?.copyWith(
+ color: Theme.of(context).colorScheme.outline,
+ ),
+ ),
+ ),
+ );late final TextEditingController controller =
+ TextEditingController(text: widget.initialText);const CardTile({
+ Key? key,
+ required this.emoji,
+ required this.title,
+ required this.description,
+ this.trailing,
+ this.onTap,
+}) : super(key: key);DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ final textTheme = Theme.of(context).textTheme;
+ // final colorScheme = Theme.of(context).colorScheme;
+
+ return ListTile(
+ onTap: onTap,
+ leading: emoji != null && emoji!.isNotEmpty
+ ? Unmoji(
+ emoji: emoji!,
+ width: 42,
+ height: 42,
+ )
+ : null,
+ title: title != null ? Text(title!, style: textTheme.titleMedium) : null,
+ subtitle: description != null
+ ? Text(description!, style: textTheme.labelSmall)
+ : null,
+ trailing: trailing,
+ // onTap: () {},
+ );
+}final String? description;final String? emoji;final GestureTapCallback? onTap;final String? title;final Widget? trailing;const ChipEmoji({
+ Key? key,
+ required this.emoji,
+ this.onSelected,
+ required this.selected,
+}) : super(key: key);DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ final colorScheme = Theme.of(context).colorScheme;
+
+ return ChoiceChip(
+ padding: const EdgeInsets.all(14.0),
+ shape: const CircleBorder(),
+ side: BorderSide(
+ width: UnStroke.L,
+ color: isEnabled
+ ? colorScheme.primary
+ : colorScheme.outline.withOpacity(0.12),
+ ),
+ selectedColor: colorScheme.primary,
+ backgroundColor: Colors.transparent,
+ disabledColor: Colors.transparent,
+ pressElevation: 0.0,
+ label: Text(
+ emoji,
+ style: UnSymbolSizes.emojiL,
+ ),
+ selected: selected,
+ onSelected: onSelected,
+ );
+}final String emoji;bool get isEnabled => onSelected != null;final ValueChanged<bool>? onSelected;final bool selected;const ChipText({
+ Key? key,
+ required this.text,
+ this.onSelected,
+ required this.selected,
+}) : super(key: key);DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ final textTheme = Theme.of(context).textTheme;
+ final colorScheme = Theme.of(context).colorScheme;
+
+ return ChoiceChip(
+ side: BorderSide(
+ width: UnStroke.L,
+ color: isEnabled
+ ? colorScheme.primary
+ : colorScheme.outline.withOpacity(0.12),
+ ),
+ selectedColor: colorScheme.primary,
+ backgroundColor: Colors.transparent,
+ disabledColor: Colors.transparent,
+ onSelected: onSelected,
+ pressElevation: 0.0,
+ label: Text(
+ text,
+ style: textTheme.labelLarge?.copyWith(
+ color: isEnabled
+ ? (selected ? colorScheme.onPrimary : colorScheme.primary)
+ : colorScheme.onSurface,
+ ),
+ ),
+ selected: selected,
+ );
+}bool get isEnabled => onSelected != null;final ValueChanged<bool>? onSelected;final bool selected;final String text;const ConditionalParentWidget({
+ super.key,
+ required this.condition,
+ required this.child,
+ required this.conditionalBuilder,
+});Conditionally wrap a subtree with a parent widget without breaking the code tree.
+condition: the condition depending on which the subtree child is wrapped with the parent. +child: The subtree that should always be build. +conditionalBuilder: builds the parent with the subtree child.
+Usage:
+return ConditionalParentWidget(
+ condition: shouldIncludeParent,
+ child: Widget1(
+ child: Widget2(
+ child: Widget3(),
+ ),
+ ),
+ conditionalBuilder: (Widget child) => SomeParentWidget(child: child),
+);
+Instead of:
+Widget child = Widget1(
+ child: Widget2(
+ child: Widget3(),
+ ),
+);
+
+return shouldIncludeParent ? SomeParentWidget(child: child) : child;
+DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) =>
+ condition ? conditionalBuilder(child) : child;final Widget child;final bool condition;final Widget Function(Widget child) conditionalBuilder;typedef ContextMenuPreviewBuilder = Widget Function(
+ BuildContext context,
+ Animation<double> animation,
+ Widget child,
+);const FloatContainer({
+ Key? key,
+ required this.child,
+ this.padding,
+}) : super(key: key);DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ final colorScheme = Theme.of(context).colorScheme;
+
+ return child != null
+ ? Container(
+ decoration: ShapeDecoration(
+ shape: SmoothRectangleBorder(
+ borderRadius: SmoothBorderRadius(cornerRadius: 48),
+ ),
+ color: colorScheme.surface,
+ shadows: [
+ BoxShadow(
+ color: colorScheme.outline.withOpacity(.16),
+ blurRadius: 10,
+ spreadRadius: 1,
+ ),
+ ],
+ ),
+ clipBehavior: Clip.antiAlias,
+ child: child,
+ )
+ : Container();
+}final Widget? child;final EdgeInsets? padding;const FloatScaffold({
+ Key? key,
+ this.leading,
+ this.middle,
+ this.trailing,
+}) : super(key: key);DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ final colorScheme = Theme.of(context).colorScheme;
+
+ return Container(
+ constraints: BoxConstraints(
+ maxHeight: MediaQuery.of(context).padding.bottom * 4.5,
+ ),
+ decoration: TranslucentDecoration(
+ gradient: LinearGradient(
+ colors: [
+ colorScheme.background.withOpacity(0),
+ colorScheme.background,
+ ],
+ begin: Alignment.topCenter,
+ end: Alignment.bottomCenter,
+ ),
+ ),
+ padding: const EdgeInsets.all(36),
+ alignment: Alignment.center,
+ child: ConstrainedBox(
+ constraints: const BoxConstraints(maxHeight: 48),
+ child: FloatContainer(
+ child: NavigationToolbar(
+ leading: leading,
+ middle: middle,
+ trailing: trailing,
+ ),
+ ),
+ ),
+ );
+}final Widget? leading;final Widget? middle;final Widget? trailing;const HeadingHeadline({
+ Key? key,
+ required this.label,
+}) : super(key: key);DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ return Padding(
+ padding: const EdgeInsets.only(
+ left: 8.0,
+ top: 32.0,
+ right: 8.0,
+ bottom: 8.0,
+ ),
+ child: Text(
+ label,
+ style: Theme.of(context).textTheme.displayMedium,
+ ),
+ );
+}final String label;const HeadingSection({
+ Key? key,
+ required this.label,
+}) : super(key: key);DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ return Padding(
+ padding: const EdgeInsets.only(
+ left: 8.0,
+ top: 32.0,
+ right: 8.0,
+ bottom: 8.0,
+ ),
+ child: Text(
+ label.toUpperCase(),
+ style: Theme.of(context).textTheme.titleMedium!.copyWith(
+ letterSpacing: 0.75,
+ ),
+ ),
+ );
+}final String label;const HeadingTitle({
+ Key? key,
+ required this.label,
+}) : super(key: key);DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ return Padding(
+ padding: const EdgeInsets.only(
+ left: 8.0,
+ top: 32.0,
+ right: 8.0,
+ bottom: 8.0,
+ ),
+ child: Text(
+ label,
+ style: Theme.of(context).textTheme.headlineMedium,
+ ),
+ );
+}final String label;const HeroTag(this.navigator);The hash code for this object.
+A hash code is a single integer which represents the state of the object +that affects operator == comparisons.
+All objects have hash codes. +The default hash code implemented by Object +represents only the identity of the object, +the same way as the default operator == implementation only considers objects +equal if they are identical (see identityHashCode).
+If operator == is overridden to use the object state instead, +the hash code must also be changed to represent that state, +otherwise the object cannot be used in hash based data structures +like the default Set and Map implementations.
+Hash codes must be the same for objects that are equal to each other +according to operator ==. +The hash code of an object should only change if the object changes +in a way that affects equality. +There are no further requirements for the hash codes. +They need not be consistent between executions of the same program +and there are no distribution guarantees.
+Objects that are not equal are allowed to have the same hash code. +It is even technically allowed that all instances have the same hash code, +but if clashes happen too often, +it may reduce the efficiency of hash-based data structures +like HashSet or HashMap.
+If a subclass overrides hashCode, it should override the +operator == operator as well to maintain consistency.
+@override
+int get hashCode => identityHashCode(navigator);final NavigatorState? navigator;The equality operator.
+The default behavior for all Objects is to return true if and
+only if this object and other are the same object.
Override this method to specify a different equality relation on +a class. The overriding method must still be an equivalence relation. +That is, it must be:
+Total: It must return a boolean for all arguments. It should never throw.
+Reflexive: For all objects o, o == o must be true.
Symmetric: For all objects o1 and o2, o1 == o2 and o2 == o1 must
+either both be true, or both be false.
Transitive: For all objects o1, o2, and o3, if o1 == o2 and
+o2 == o3 are true, then o1 == o3 must be true.
The method should also be consistent over time, +so whether two objects are equal should only change +if at least one of the objects was modified.
+If a subclass overrides the equality operator, it should override +the hashCode method as well to maintain consistency.
+@override
+bool operator ==(Object other) {
+ if (identical(this, other)) {
+ return true;
+ }
+ if (other.runtimeType != runtimeType) {
+ return false;
+ }
+
+ return other is HeroTag && other.navigator == navigator;
+}A string representation of this object.
+Some classes have a default textual representation,
+often paired with a static parse function (like int.parse).
+These classes will provide the textual representation as
+their string representation.
Other classes have no meaningful textual representation
+that a program will care about.
+Such classes will typically override toString to provide
+useful information when inspecting the object,
+mainly for debugging or logging.
@override
+String toString() =>
+ 'Default Hero tag for Cupertino navigation bars with navigator \$navigator';static Widget section(text) => Padding(
+ padding: const EdgeInsets.fromLTRB(16, 36, 16, 12),
+ child: Text(text),
+ );static Widget tile(MapEntry<String, FutureOr<void> Function()?> entry) =>
+ ListTile(
+ title: Text(entry.key),
+ trailing: const Icon(UnSymbols.chevronForward),
+ onTap: entry.value,
+ );const NavigationContext({
+ super.key,
+ required super.child,
+ this.exit,
+});DiagnosticsNode objects describing this node's
+children.
+ final Widget? exit;static NavigationContext? of(BuildContext context) =>
+ context.dependOnInheritedWidgetOfExactType<NavigationContext>();Whether the framework should notify widgets that inherit from this widget.
+When this widget is rebuilt, sometimes we need to rebuild the widgets that
+inherit from this widget but sometimes we do not. For example, if the data
+held by this widget is the same as the data held by oldWidget, then we
+do not need to rebuild the widgets that inherited the data held by
+oldWidget.
The framework distinguishes these cases by calling this function with the +widget that previously occupied this location in the tree as an argument. +The given widget is guaranteed to have the same runtimeType as this +object.
+@override
+bool updateShouldNotify(NavigationContext oldWidget) =>
+ exit != oldWidget.exit;PairingScrollController({
+ Key? key,
+ required this.group,
+ required super.child,
+}) : super(
+ key: key,
+ controller: group._mirror,
+ );TargetPlatforms this controller is configured for ScrollViews to
+automatically inherit.
+ DiagnosticsNode objects describing this node's
+children.
+ Add additional properties associated with the node.
+Use the most specific DiagnosticsProperty existing subclass to describe +each property instead of the DiagnosticsProperty base class. There are +only a small number of DiagnosticsProperty subclasses each covering a +common use case. Consider what values a property is relevant for users +debugging as users debugging large trees are overloaded with information. +Common named parameters in DiagnosticsNode subclasses help filter when +and how properties are displayed.
+defaultValue, showName, showSeparator, and level keep string
+representations of diagnostics terse and hide properties when they are not
+very useful.
defaultValue any time the default value of a property is
+uninteresting. For example, specify a default value of null any time
+a property being null does not indicate an error.level parameter unless the result you want
+cannot be achieved by using the defaultValue parameter or using
+the ObjectFlagProperty class to conditionally display the property
+as a flag.showName and showSeparator in rare cases where the string
+output would look clumsy if they were not set.
+DiagnosticsProperty<Object>('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()
+showSeparator to get output child(3, 4) is null which
+is more polished than child(3, 4): is null.
+DiagnosticsProperty<IconData>('icon', icon, ifNull: '<empty>', showName: false).toString()
+showName to omit the property name as in this context the
+property name does not add useful information.ifNull, ifEmpty, unit, and tooltip make property
+descriptions clearer. The examples in the code sample below illustrate
+good uses of all of these parameters.
DiagnosticsProperty<bool> instead of using FlagProperty as the
+output is more verbose but unambiguous.toString implementation for Dart
+enum types.onClick
+callback is specified or an animation is in progress.If none of these subclasses apply, use the DiagnosticsProperty
+constructor or in rare cases create your own DiagnosticsProperty
+subclass as in the case for TransformProperty which handles Matrix4
+that represent transforms. Generally any property value with a good
+toString method implementation works fine using DiagnosticsProperty
+directly.
{@tool snippet}
+This example shows best practices for implementing debugFillProperties +illustrating use of all common DiagnosticsProperty subclasses and all +common DiagnosticsProperty parameters.
+class ExampleObject extends ExampleSuperclass {
+
+ // ...various members and properties...
+
+ @override
+ void debugFillProperties(DiagnosticPropertiesBuilder properties) {
+ // Always add properties from the base class first.
+ super.debugFillProperties(properties);
+
+ // Omit the property name 'message' when displaying this String property
+ // as it would just add visual noise.
+ properties.add(StringProperty('message', message, showName: false));
+
+ properties.add(DoubleProperty('stepWidth', stepWidth));
+
+ // A scale of 1.0 does nothing so should be hidden.
+ properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));
+
+ // If the hitTestExtent matches the paintExtent, it is just set to its
+ // default value so is not relevant.
+ properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));
+
+ // maxWidth of double.infinity indicates the width is unconstrained and
+ // so maxWidth has no impact.
+ properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));
+
+ // Progress is a value between 0 and 1 or null. Showing it as a
+ // percentage makes the meaning clear enough that the name can be
+ // hidden.
+ properties.add(PercentProperty(
+ 'progress',
+ progress,
+ showName: false,
+ ifNull: '<indeterminate>',
+ ));
+
+ // Most text fields have maxLines set to 1.
+ properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));
+
+ // Specify the unit as otherwise it would be unclear that time is in
+ // milliseconds.
+ properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));
+
+ // Tooltip is used instead of unit for this case as a unit should be a
+ // terse description appropriate to display directly after a number
+ // without a space.
+ properties.add(DoubleProperty(
+ 'device pixel ratio',
+ ui.window.devicePixelRatio,
+ tooltip: 'physical pixels per logical pixel',
+ ));
+
+ // Displaying the depth value would be distracting. Instead only display
+ // if the depth value is missing.
+ properties.add(ObjectFlagProperty<int>('depth', depth, ifNull: 'no depth'));
+
+ // bool flag that is only shown when the value is true.
+ properties.add(FlagProperty('using primary controller', value: primary));
+
+ properties.add(FlagProperty(
+ 'isCurrent',
+ value: isCurrent,
+ ifTrue: 'active',
+ ifFalse: 'inactive',
+ ));
+
+ properties.add(DiagnosticsProperty<bool>('keepAlive', keepAlive));
+
+ // FlagProperty could have also been used in this case.
+ // This option results in the text "obscureText: true" instead
+ // of "obscureText" which is a bit more verbose but a bit clearer.
+ properties.add(DiagnosticsProperty<bool>('obscureText', obscureText, defaultValue: false));
+
+ properties.add(EnumProperty<TextAlign>('textAlign', textAlign, defaultValue: null));
+ properties.add(EnumProperty<ImageRepeat>('repeat', repeat, defaultValue: ImageRepeat.noRepeat));
+
+ // Warn users when the widget is missing but do not show the value.
+ properties.add(ObjectFlagProperty<Widget>('widget', widget, ifNull: 'no widget'));
+
+ properties.add(IterableProperty<BoxShadow>(
+ 'boxShadow',
+ boxShadow,
+ defaultValue: null,
+ style: style,
+ ));
+
+ // Getting the value of size throws an exception unless hasSize is true.
+ properties.add(DiagnosticsProperty<Size>.lazy(
+ 'size',
+ () => size,
+ description: '\${ hasSize ? size : "MISSING" }',
+ ));
+
+ // If the \`toString\` method for the property value does not provide a
+ // good terse description, write a DiagnosticsProperty subclass as in
+ // the case of TransformProperty which displays a nice debugging view
+ // of a Matrix4 that represents a transform.
+ properties.add(TransformProperty('transform', transform));
+
+ // If the value class has a good \`toString\` method, use
+ // DiagnosticsProperty<YourValueType>. Specifying the value type ensures
+ // that debugging tools always know the type of the field and so can
+ // provide the right UI affordances. For example, in this case even
+ // if color is null, a debugging tool still knows the value is a Color
+ // and can display relevant color related UI.
+ properties.add(DiagnosticsProperty<Color>('color', color));
+
+ // Use a custom description to generate a more terse summary than the
+ // \`toString\` method on the map class.
+ properties.add(DiagnosticsProperty<Map<Listenable, VoidCallback>>(
+ 'handles',
+ handles,
+ description: handles != null
+ ? '\${handles!.length} active client\${ handles!.length == 1 ? "" : "s" }'
+ : null,
+ ifNull: 'no notifications ever received',
+ showName: false,
+ ));
+ }
+}
+{@end-tool}
+Used by toDiagnosticsNode and toString.
+@override
+void debugFillProperties(DiagnosticPropertiesBuilder properties) {
+ super.debugFillProperties(properties);
+ properties.add(DiagnosticsProperty<PairingScrollControllerGroup>(
+ 'group',
+ group,
+ ifNull: 'no controller',
+ showName: false,
+ ));
+}final PairingScrollControllerGroup group;Returns the ScrollController most closely associated with the given +context.
+If no ancestor is found, this method will assert in debug mode, and throw +an exception in release mode.
+Calling this method will create a dependency on the closest
+PrimaryScrollController in the context.
See also:
+static PairingScrollControllerGroup? of(BuildContext context) => context
+ .dependOnInheritedWidgetOfExactType<PairingScrollController>()
+ ?.group;Whether the framework should notify widgets that inherit from this widget.
+When this widget is rebuilt, sometimes we need to rebuild the widgets that
+inherit from this widget but sometimes we do not. For example, if the data
+held by this widget is the same as the data held by oldWidget, then we
+do not need to rebuild the widgets that inherited the data held by
+oldWidget.
The framework distinguishes these cases by calling this function with the +widget that previously occupied this location in the tree as an argument. +The given widget is guaranteed to have the same runtimeType as this +object.
+@override
+bool updateShouldNotify(PairingScrollController oldWidget) =>
+ group._mirror != oldWidget.group._mirror ||
+ group._offsetNotifier != oldWidget.group._offsetNotifier ||
+ !listEquals(group._actors, oldWidget.group._actors);PairingScrollControllerGroup() {
+ _offsetNotifier = _PairedScrollControllerGroupOffsetNotifier(this);
+ _mirror = _PairedScrollController(this);
+ _mirror.addListener(_offsetNotifier.notifyListeners);
+}void addOffsetChangedListener(VoidCallback onChanged) =>
+ _offsetNotifier.addListener(onChanged);Future<void> animateTo(
+ double offset, {
+ required Curve curve,
+ required Duration duration,
+}) async {
+ final animations = <Future<void>>[];
+ for (final controller in _attachedControllers) {
+ animations
+ .add(controller.animateTo(offset, duration: duration, curve: curve));
+ }
+
+ return Future.wait<void>(animations).then<void>((List<void> _) => null);
+}void jumpTo(double value) {
+ for (final controller in _attachedControllers) {
+ controller.jumpTo(value);
+ }
+}double get offset {
+ assert(
+ _attachedControllers.isNotEmpty,
+ 'PairedScrollControllerGroup does not have any scroll controllers '
+ 'attached.',
+ );
+
+ return _attachedControllers.last.offset;
+}ScrollController push() {
+ final controller = _PairedScrollController(this);
+ _actors.add(controller);
+ controller.addListener(_offsetNotifier.notifyListeners);
+
+ if (_actors.isNotEmpty) {
+ _actors.last.removeListener(_offsetNotifier.notifyListeners);
+ _actors.last.addListener(_offsetNotifier.notifyListeners);
+ }
+
+ return controller;
+}void removeOffsetChangedListener(VoidCallback listener) =>
+ _offsetNotifier.removeListener(listener);void resetScroll() {
+ jumpTo(0.0);
+}A wrapper around LayoutBuilder which exposes builders for +various responsive breakpoints.
+const ResponsiveLayoutBuilder({
+ Key? key,
+ required this.small,
+ required this.large,
+ this.medium,
+ this.xLarge,
+ this.child,
+}) : super(key: key);A wrapper around LayoutBuilder which exposes builders for +various responsive breakpoints.
+small, large and xLarge
+builders as a way to share/optimize shared layout.
+ DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ return LayoutBuilder(
+ builder: (context, constraints) {
+ if (constraints.maxWidth <= UnBreakpoints.small) {
+ return small(context, child);
+ } else if (constraints.maxWidth <= UnBreakpoints.medium) {
+ return (medium ?? large).call(context, child);
+ } else if (constraints.maxWidth <= UnBreakpoints.large) {
+ return large(context, child);
+ } else {
+ return (xLarge ?? large).call(context, child);
+ }
+ },
+ );
+}Optional child widget which will be passed
+to the small, large and xLarge
+builders as a way to share/optimize shared layout.
final Widget? child;ResponsiveLayoutWidgetBuilder for large layout.
+final ResponsiveLayoutWidgetBuilder large;ResponsiveLayoutWidgetBuilder for medium layout.
+final ResponsiveLayoutWidgetBuilder? medium;ResponsiveLayoutWidgetBuilder for small layout.
+final ResponsiveLayoutWidgetBuilder small;ResponsiveLayoutWidgetBuilder for xLarge layout.
+final ResponsiveLayoutWidgetBuilder? xLarge;Signature for the individual builders (small, large, etc.).
typedef ResponsiveLayoutWidgetBuilder = Widget Function(BuildContext, Widget?);const TextArea({
+ Key? key,
+ this.onChanged,
+ this.onTap,
+ this.autofocus,
+ this.controller,
+}) : super(key: key);DiagnosticsNode objects describing this node's
+children.
+ final bool? autofocus;Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ final textTheme = Theme.of(context).textTheme;
+
+ return Expanded(
+ child: TextField(
+ controller: controller,
+ autofocus: autofocus ?? false,
+ onChanged: onChanged,
+ textAlign: TextAlign.center,
+ textAlignVertical: TextAlignVertical.center,
+ style: textTheme.bodyLarge,
+ expands: true,
+ maxLines: null,
+ // maxLength: 280,
+ onTap: onTap,
+ decoration: const InputDecoration(
+ hintText: 'Start Writing...',
+ border: InputBorder.none,
+ // contentPadding: EdgeInsets.only(
+ // top: 16.0,
+ // left: 16.0,
+ // right: 16.0,
+ // bottom: 16.0,
+ // ),
+ ),
+
+ // buildCounter: (
+ // _, {
+ // required currentLength,
+ // maxLength,
+ // required isFocused,
+ // }) =>
+ // Container(
+ // height: 16,
+ // alignment: Alignment.center,
+ // child: Text(
+ // isFocused ? "\$currentLength / \$maxLength" : "",
+ // textAlign: TextAlign.center,
+ // style: textTheme.labelMedium,
+ // ),
+ // ),
+ ),
+ );
+}final TextEditingController? controller;final ValueChanged<String>? onChanged;final GestureTapCallback? onTap;const TextBox({
+ super.key,
+ this.hintText,
+});DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ final textTheme = Theme.of(context).textTheme;
+
+ return Card(
+ elevation: 0,
+ clipBehavior: Clip.antiAliasWithSaveLayer,
+ shape: SmoothRectangleBorder(
+ side: BorderSide(
+ color: Theme.of(context).colorScheme.outline,
+ width: UnStroke.L,
+ ),
+ borderRadius: const SmoothBorderRadius.all(
+ SmoothRadius(
+ cornerRadius: UnCorner.Large,
+ cornerSmoothing: UnCorner.smoothFactor,
+ ),
+ ),
+ ),
+ child: Padding(
+ padding: const EdgeInsets.only(
+ left: 16.0,
+ right: 16.0,
+ top: 8.0,
+ bottom: 8.0,
+ ),
+ child: TextField(
+ controller: TextEditingController(),
+ style: textTheme.bodyLarge,
+ maxLines: 5,
+ decoration: InputDecoration(
+ hintText: hintText ?? 'Start Writing...',
+ border: InputBorder.none,
+ ),
+ ),
+ ),
+ );
+}final String? hintText;const TranslucentDecoration({
+ super.color,
+ super.image,
+ super.border,
+ super.borderRadius,
+ super.boxShadow,
+ super.gradient,
+ super.backgroundBlendMode,
+ super.shape = BoxShape.rectangle,
+});this.
+ this to another Decoration (which may be of
+a different class).
+ Tests whether the given point, on a rectangle of a given size, +would be considered to hit the decoration or not. For example, +if the decoration only draws a circle, this function might +return true if the point was inside the circle and false +otherwise.
+The decoration may be sensitive to the TextDirection. The
+textDirection argument should therefore be provided. If it is known that
+the decoration is not affected by the text direction, then the argument
+may be omitted or set to null.
When a Decoration is painted in a Container or DecoratedBox (which
+is what Container uses), the textDirection parameter will be populated
+based on the ambient Directionality (by way of the RenderDecoratedBox
+renderer).
@override
+bool hitTest(Size size, Offset position, {TextDirection? textDirection}) =>
+ false;const UnAppPage({
+ super.key,
+ required this.name,
+ this.description,
+ required this.slivers,
+ this.implyLeading = true,
+ this.leading,
+ this.trailing,
+ this.isImmersive = false,
+});DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => UnScaffold(
+ slivers: [
+ UnSliverAppBar(
+ title: name,
+ description: description,
+ implyLeading: implyLeading,
+ leading: leading,
+ trailing: trailing,
+ isImmersive: isImmersive,
+ ),
+ ...slivers,
+ ],
+ );final Widget? description;final bool implyLeading;final bool isImmersive;final Widget? leading;final Widget name;final List<Widget> slivers;final Widget? trailing;const UnArtPage({
+ super.key,
+ required this.emoji,
+ required this.name,
+ this.description,
+ this.action,
+ this.background,
+ required this.slivers,
+ this.leading,
+ this.trailing,
+});DiagnosticsNode objects describing this node's
+children.
+ final Widget? action;final Widget? background;Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => UnScaffold(
+ slivers: [
+ UnSliverArtBar(
+ emoji: emoji,
+ name: name,
+ description: description,
+ action: action,
+ background: background,
+ leading: leading,
+ trailing: trailing,
+ ),
+ ...slivers,
+ ],
+ );final Widget? description;final Widget emoji;final Widget? leading;final Widget name;final List<Widget> slivers;final Widget? trailing;const UnCard({
+ super.key,
+ this.header,
+ required this.body,
+ this.footer,
+ this.isSelected = false,
+ this.isExpandable = false,
+ this.onTap,
+});DiagnosticsNode objects describing this node's
+children.
+ final Widget body;Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => Card(
+ elevation: 1,
+ clipBehavior: Clip.antiAliasWithSaveLayer,
+ shape: const SmoothRectangleBorder(
+ borderRadius: SmoothBorderRadius.all(
+ SmoothRadius(
+ cornerRadius: UnCorner.Large,
+ cornerSmoothing: UnCorner.smoothFactor,
+ ),
+ ),
+ ),
+ child: InkWell(
+ onTap: onTap,
+ child: Padding(
+ padding: const EdgeInsets.symmetric(
+ vertical: 12.0,
+ horizontal: 8.0,
+ ),
+ child: AnimatedSize(
+ alignment: Alignment.topCenter,
+ duration: UnDurations.moderate,
+ curve: UnEasing.linear,
+ child: ConditionalParentWidget(
+ condition: isSelected || !isExpandable,
+ conditionalBuilder: (child) =>
+ AspectRatio(aspectRatio: 1, child: child),
+ child: Column(
+ children: [
+ if (header != null) header!,
+ if (isSelected || !isExpandable)
+ Expanded(child: Center(child: body)),
+ if (footer != null) footer!,
+ ],
+ ),
+ ),
+ ),
+ ),
+ ),
+ );final Widget? footer;final Widget? header;final bool isExpandable;final bool isSelected;final GestureTapCallback? onTap;UnCupertinoContextMenu({
+ super.key,
+ required this.actions,
+ this.onTap,
+ required this.child,
+ this.previewBuilder,
+}) : assert(actions.isNotEmpty);DiagnosticsNode objects describing this node's
+children.
+ final List<Widget> actions;final Widget child;Creates the mutable state for this widget at a given location in the tree.
+Subclasses should override this method to return a newly created +instance of their associated State subclass:
+@override
+State<SomeWidget> createState() => _SomeWidgetState();
+The framework can call this method multiple times over the lifetime of
+a StatefulWidget. For example, if the widget is inserted into the tree
+in multiple locations, the framework will create a separate State object
+for each location. Similarly, if the widget is removed from the tree and
+later inserted into the tree again, the framework will call createState
+again to create a fresh State object, simplifying the lifecycle of
+State objects.
@override
+State<UnCupertinoContextMenu> createState() => _UnCupertinoContextMenuState();final Function()? onTap;final ContextMenuPreviewBuilder? previewBuilder;const UnRootSheetPage({
+ required this.child,
+ this.maintainState = true,
+ this.fullscreenDialog = false,
+ super.key,
+ super.name,
+ super.arguments,
+ super.restorationId,
+});other page.
+ final Widget child;Creates the Route that corresponds to this page.
+The created Route must have its Route.settings property set to this Page.
+@override
+Route<T> createRoute(BuildContext context) =>
+ _PageBasedMaterialWithModalsPageRoute<T>(page: this);final bool fullscreenDialog;final bool maintainState;const UnScaffold({
+ super.key,
+ required this.slivers,
+ this.controller,
+ this.physics,
+});DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => Container(
+ decoration: BoxDecoration(
+ color: Theme.of(context).colorScheme.background,
+ ),
+ child: CustomScrollView(
+ controller: controller,
+ physics: physics ??
+ const BouncingScrollPhysics(
+ parent: AlwaysScrollableScrollPhysics(),
+ ),
+ keyboardDismissBehavior: ScrollViewKeyboardDismissBehavior.onDrag,
+ slivers: [
+ ...slivers,
+ SliverPadding(
+ padding: EdgeInsets.only(
+ bottom: MediaQuery.of(context).padding.bottom * 2,
+ ),
+ ),
+ ],
+ ),
+ );final ScrollController? controller;final ScrollPhysics? physics;final List<Widget> slivers;const UnSheet({
+ required this.child,
+ this.topRadius,
+ this.transitionBackgroundColor = Colors.black,
+ this.overlayStyle,
+ this.backgroundColor,
+ this.elevation,
+ this.closeProgressThreshold,
+ this.shape,
+ this.clipBehavior,
+ this.barrierColor,
+ this.expand = false,
+ this.secondAnimation,
+ this.animationCurve,
+ this.previousRouteAnimationCurve,
+ this.useRootNavigator = false,
+ this.bounce = true,
+ this.isDismissible,
+ this.enableDrag = true,
+ this.duration,
+ this.settings,
+ this.shadow,
+ super.key,
+ super.name,
+ super.arguments,
+ super.restorationId,
+});other page.
+ final Curve? animationCurve;final Color? backgroundColor;final Color? barrierColor;final bool bounce;final Widget child;final Clip? clipBehavior;final double? closeProgressThreshold;Creates the Route that corresponds to this page.
+The created Route must have its Route.settings property set to this Page.
+@override
+Route<T> createRoute(BuildContext context) => CupertinoModalBottomSheetRoute(
+ settings: this,
+ builder: (context) => Material(child: child),
+ containerBuilder: (context, animation, child) => _SheetContainer(
+ topRadius: topRadius ?? UnTheme.screenCornerRadius(context),
+ backgroundColor: backgroundColor,
+ child: child,
+ ),
+ secondAnimationController: secondAnimation,
+ expanded: expand,
+ closeProgressThreshold: closeProgressThreshold,
+ barrierLabel: Localizations.of<MaterialLocalizations>(
+ context,
+ MaterialLocalizations,
+ ) !=
+ null
+ ? MaterialLocalizations.of(context).modalBarrierDismissLabel
+ : '',
+ elevation: elevation,
+ bounce: bounce,
+ shape: shape,
+ clipBehavior: clipBehavior,
+ isDismissible: isDismissible ?? !expand ? true : false,
+ modalBarrierColor: barrierColor ?? Colors.black12,
+ enableDrag: enableDrag,
+ topRadius: topRadius ?? UnTheme.screenCornerRadius(context),
+ animationCurve: animationCurve,
+ previousRouteAnimationCurve: previousRouteAnimationCurve,
+ duration: duration,
+ transitionBackgroundColor: transitionBackgroundColor ?? Colors.black,
+ overlayStyle: overlayStyle,
+ );final Duration? duration;final double? elevation;final bool enableDrag;final bool expand;final bool? isDismissible;final SystemUiOverlayStyle? overlayStyle;final Curve? previousRouteAnimationCurve;final AnimationController? secondAnimation;final RouteSettings? settings;final BoxShadow? shadow;final ShapeBorder? shape;final SmoothRadius? topRadius;final Color? transitionBackgroundColor;final bool useRootNavigator;const UnSliverAppBar({
+ super.key,
+ this.emoji,
+ required this.title,
+ this.description,
+ this.implyLeading = true,
+ this.leading,
+ this.trailing,
+ this.isImmersive = false,
+ this.isCollapseCentered = true,
+});DiagnosticsNode objects describing this node's
+children.
+ Creates the mutable state for this widget at a given location in the tree.
+Subclasses should override this method to return a newly created +instance of their associated State subclass:
+@override
+State<SomeWidget> createState() => _SomeWidgetState();
+The framework can call this method multiple times over the lifetime of
+a StatefulWidget. For example, if the widget is inserted into the tree
+in multiple locations, the framework will create a separate State object
+for each location. Similarly, if the widget is removed from the tree and
+later inserted into the tree again, the framework will call createState
+again to create a fresh State object, simplifying the lifecycle of
+State objects.
@override
+State<UnSliverAppBar> createState() => _UnSliverAppBarState();final Widget? description;final String? emoji;final bool implyLeading;final bool isCollapseCentered;final bool isImmersive;final Widget? leading;final Widget title;final Widget? trailing;const UnSliverArtBar({
+ super.key,
+ required this.emoji,
+ required this.name,
+ required this.description,
+ required this.action,
+ this.background,
+ this.leading,
+ this.trailing,
+ this.isImmersive = false,
+});DiagnosticsNode objects describing this node's
+children.
+ final Widget? action;final Widget? background;Creates the mutable state for this widget at a given location in the tree.
+Subclasses should override this method to return a newly created +instance of their associated State subclass:
+@override
+State<SomeWidget> createState() => _SomeWidgetState();
+The framework can call this method multiple times over the lifetime of
+a StatefulWidget. For example, if the widget is inserted into the tree
+in multiple locations, the framework will create a separate State object
+for each location. Similarly, if the widget is removed from the tree and
+later inserted into the tree again, the framework will call createState
+again to create a fresh State object, simplifying the lifecycle of
+State objects.
@override
+State<UnSliverArtBar> createState() => _UnSliverArtBarState();final Widget? description;final Widget emoji;final bool isImmersive;final Widget? leading;final Widget name;final Widget? trailing;typedef UnTransitionPage = CupertinoPage;const Unmoji({
+ Key? key,
+ required this.emoji,
+ this.height,
+ this.width,
+ this.twemojiFormat = UnmojiFormat.webp,
+ this.fit,
+}) : super(key: key);returns an image of an emoji
+The format of the emoji image it can be UnmojiFormat.webp +72*72 png or UnmojiFormat.svg svg by default.
+DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ if (unicode == '') return const SizedBox.shrink();
+
+ switch (twemojiFormat) {
+ case UnmojiFormat.webp:
+ return Image.asset(
+ 'assets/emojis/\$unicode.webp',
+ fit: fit,
+ height: width,
+ width: height,
+ package: 'un_style',
+ );
+ case UnmojiFormat.svg:
+ return SvgPicture.asset(
+ 'assets/svg/\$unicode.svg',
+ height: height,
+ width: width,
+ fit: fit ?? BoxFit.contain,
+ package: 'un_style',
+ );
+ case UnmojiFormat.networkSvg:
+ return SvgPicture.network(
+ 'https://abs.twimg.com/emoji/v2/svg/\$unicode.svg',
+ height: height,
+ width: width,
+ fit: fit ?? BoxFit.contain,
+ );
+ }
+}The emoji string
+on passing a string with text and emojis it will show the last emoji +in that string
+final String emoji;How to inscribe the image into the space allocated during layout.
+The default varies based on the other fields. See the discussion at +paintImage.
+final BoxFit? fit;final double? height;The format of the emoji image it can be UnmojiFormat.webp +72*72 png or UnmojiFormat.svg svg by default.
+Note: svg does'nt works on Flutter html web renderer
+final UnmojiFormat twemojiFormat;String get unicode {
+ var cleanEmoji = '';
+ emoji.splitMapJoin(
+ regex,
+ onMatch: (m) => cleanEmoji = m.input.substring(m.start, m.end),
+ );
+
+ return emojiToUnicode(cleanEmoji);
+}final double? width;SVG form assets
+ + +PNG form assets
+ + +SVG form Network
+ + +[svg, webp, networkSvg]
+ A constant List of the values in this enum, in order of their declaration.
+const UnmojiText({
+ Key? key,
+ required this.text,
+ this.style,
+ this.maxLines,
+ this.emojiFontMultiplier = 1.0,
+ this.twemojiFormat = UnmojiFormat.svg,
+}) : super(key: key);returns a widget with rendered text with twitter emojis
+DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => RichText(
+ text: UnmojiTextSpan(
+ text: text,
+ emojiFontMultiplier: emojiFontMultiplier,
+ twemojiFormat: twemojiFormat,
+ style: style,
+ ),
+ maxLines: maxLines,
+ );Multiplie the emoji size, by default it's 1
+final double emojiFontMultiplier;Maximal lines to be rendered
+final int? maxLines;Describes the font style and the emoji size
+final TextStyle? style;The Text
+final String text;The format of the emoji image it can be UnmojiFormat.webp +72*72 png or UnmojiFormat.svg svg by default.
+final UnmojiFormat twemojiFormat;UnmojiTextSpan({
+ TextStyle? style,
+ required String text,
+ List<TextSpan>? children,
+ double emojiFontMultiplier = 1,
+ this.twemojiFormat = UnmojiFormat.svg,
+}) : super(
+ style: style,
+ children: _parse(style, text, twemojiFormat, emojiFontMultiplier)
+ ..addAll(children ?? []),
+ );The UnmojiTextSpan widget extends TextSpan +widget and it can be used in a RichText widget +and it also renders text with twitter emojis
+index in the flattened string.
+ index falls within the range
+of the span and returns the corresponding code unit. Returns null otherwise.
+ buffer.
+ DiagnosticsNode objects describing this node's
+children.
+ semanticsOffsets and semanticsElements with the appropriate data
+to be able to construct a SemanticsNode.
+ InlineSpanSemanticsInformation objects.
+ visitor
+for each span that has text.
+ final UnmojiFormat twemojiFormat;const UnselfExtendedSliverNavigationBar({
+ Key? key,
+ this.largeTitle,
+ this.leading,
+ this.automaticallyImplyLeading = true,
+ this.automaticallyImplyTitle = true,
+ this.previousPageTitle,
+ this.middle,
+ this.trailing,
+ this.border = _kDefaultNavBarBorder,
+ this.backgroundColor,
+ this.brightness,
+ this.padding,
+ this.transitionBetweenRoutes = true,
+ this.heroTag = defaultHeroTag,
+ this.stretch = false,
+}) : assert(
+ automaticallyImplyTitle || largeTitle != null,
+ 'No largeTitle has been provided but automaticallyImplyTitle is also '
+ 'false. Either provide a largeTitle or set automaticallyImplyTitle to '
+ 'true.',
+ ),
+ super(key: key);DiagnosticsNode objects describing this node's
+children.
+ final bool automaticallyImplyLeading;final bool automaticallyImplyTitle;final Color? backgroundColor;final Border? border;final Brightness? brightness;Creates the mutable state for this widget at a given location in the tree.
+Subclasses should override this method to return a newly created +instance of their associated State subclass:
+@override
+State<SomeWidget> createState() => _SomeWidgetState();
+The framework can call this method multiple times over the lifetime of
+a StatefulWidget. For example, if the widget is inserted into the tree
+in multiple locations, the framework will create a separate State object
+for each location. Similarly, if the widget is removed from the tree and
+later inserted into the tree again, the framework will call createState
+again to create a fresh State object, simplifying the lifecycle of
+State objects.
@override
+State<UnselfExtendedSliverNavigationBar> createState() =>
+ _UnselfExtendedSliverNavigationBarState();final Object heroTag;final Widget? largeTitle;final Widget? leading;final Widget? middle;bool get opaque => backgroundColor?.alpha == 0xFF;final EdgeInsetsDirectional? padding;final String? previousPageTitle;final bool stretch;final Widget? trailing;final bool transitionBetweenRoutes;const UnselfNavigationBar({
+ Key? key,
+ this.leading,
+ this.automaticallyImplyLeading = true,
+ this.automaticallyImplyMiddle = true,
+ this.previousPageTitle,
+ this.middle,
+ this.trailing,
+ this.border = _kDefaultNavBarBorder,
+ this.backgroundColor,
+ this.brightness,
+ this.padding,
+ this.transitionBetweenRoutes = true,
+ this.heroTag = defaultHeroTag,
+}) : assert(
+ !transitionBetweenRoutes || identical(heroTag, defaultHeroTag),
+ 'Cannot specify a heroTag override if this navigation bar does not '
+ 'transition due to transitionBetweenRoutes = false.',
+ ),
+ super(key: key);DiagnosticsNode objects describing this node's
+children.
+ final bool automaticallyImplyLeading;final bool automaticallyImplyMiddle;final Color? backgroundColor;final Border? border;final Brightness? brightness;Creates the mutable state for this widget at a given location in the tree.
+Subclasses should override this method to return a newly created +instance of their associated State subclass:
+@override
+State<SomeWidget> createState() => _SomeWidgetState();
+The framework can call this method multiple times over the lifetime of
+a StatefulWidget. For example, if the widget is inserted into the tree
+in multiple locations, the framework will create a separate State object
+for each location. Similarly, if the widget is removed from the tree and
+later inserted into the tree again, the framework will call createState
+again to create a fresh State object, simplifying the lifecycle of
+State objects.
@override
+State<UnselfNavigationBar> createState() => _UnselfNavigationBarState();final Object heroTag;final Widget? leading;final Widget? middle;final EdgeInsetsDirectional? padding;The size this widget would prefer if it were otherwise unconstrained.
+In many cases it's only necessary to define one preferred dimension.
+For example the Scaffold only depends on its app bar's preferred
+height. In that case implementations of this method can just return
+Size.fromHeight(myAppBarHeight).
@override
+Size get preferredSize {
+ return const Size.fromHeight(_kNavBarPersistentHeight);
+}final String? previousPageTitle;If true, this widget fully obstructs widgets behind it by the specified +size.
+If false, this widget partially obstructs.
+@override
+bool shouldFullyObstruct(BuildContext context) {
+ final Color backgroundColor =
+ Theme.of(context).appBarTheme.backgroundColor!;
+
+ return backgroundColor.alpha == 0xFF;
+}final Widget? trailing;final bool transitionBetweenRoutes;const UnselfNavigationBarBackButton({
+ Key? key,
+ this.color,
+ this.previousPageTitle,
+ this.onPressed,
+}) : _backChevron = null,
+ _backLabel = null,
+ super(key: key);DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ final ModalRoute<dynamic>? currentRoute = ModalRoute.of(context);
+ if (onPressed == null) {
+ assert(
+ currentRoute?.canPop ?? false,
+ 'UnselfNavigationBarBackButton should only be used in routes that can be popped',
+ );
+ }
+
+ // TextStyle actionTextStyle = Theme.of(context).textTheme.labelMedium!;
+ // if (color != null) {
+ // actionTextStyle = actionTextStyle.copyWith(
+ // color: Theme.of(context).colorScheme.primary,
+ // );
+ // }
+
+ // return const Icon(UnSymbols.chevronBack);
+
+ return Row(
+ mainAxisSize: MainAxisSize.min,
+ children: [
+ IconButton(
+ onPressed: () {
+ if (onPressed != null) {
+ onPressed!();
+ } else {
+ Navigator.maybePop(context);
+ }
+ },
+ icon: Icon(
+ UnSymbols.chevronBack,
+ color: Theme.of(context).colorScheme.onSurface,
+ ),
+
+ // highlightColor: Colors.transparent,
+ ),
+ _backLabel ??
+ _BackLabel(
+ specifiedPreviousTitle: previousPageTitle,
+ route: currentRoute,
+ ),
+ ],
+ );
+
+ // cupertino.CupertinoButton(
+ // padding: EdgeInsets.zero,
+ // child: Semantics(
+ // container: true,
+ // excludeSemantics: true,
+ // label: 'Back',
+ // button: true,
+ // child: DefaultTextStyle(
+ // style: actionTextStyle,
+ // child: ConstrainedBox(
+ // constraints:
+ // const BoxConstraints(minWidth: _kNavBarBackButtonTapWidth),
+ // child: Row(
+ // mainAxisSize: MainAxisSize.min,
+ // children: <Widget>[
+ // const Padding(padding: EdgeInsetsDirectional.only(start: 8.0)),
+ // _backChevron ?? const _BackChevron(),
+ // const Padding(padding: EdgeInsetsDirectional.only(start: 6.0)),
+ // Flexible(
+ // child: _backLabel ??
+ // _BackLabel(
+ // specifiedPreviousTitle: previousPageTitle,
+ // route: currentRoute,
+ // ),
+ // ),
+ // ],
+ // ),
+ // ),
+ // ),
+ // ),
+ // onPressed: () {
+ // if (onPressed != null) {
+ // onPressed!();
+ // } else {
+ // Navigator.maybePop(context);
+ // }
+ // },
+ // );
+}final Color? color;final VoidCallback? onPressed;final String? previousPageTitle;const UnselfSliverNavigationBar({
+ Key? key,
+ this.largeTitle,
+ this.leading,
+ this.automaticallyImplyLeading = true,
+ this.automaticallyImplyTitle = true,
+ this.previousPageTitle,
+ this.middle,
+ this.trailing,
+ this.border = _kDefaultNavBarBorder,
+ this.backgroundColor,
+ this.brightness,
+ this.padding,
+ this.transitionBetweenRoutes = true,
+ this.heroTag = defaultHeroTag,
+ this.stretch = false,
+}) : assert(
+ automaticallyImplyTitle || largeTitle != null,
+ 'No largeTitle has been provided but automaticallyImplyTitle is also '
+ 'false. Either provide a largeTitle or set automaticallyImplyTitle to '
+ 'true.',
+ ),
+ super(key: key);DiagnosticsNode objects describing this node's
+children.
+ final bool automaticallyImplyLeading;final bool automaticallyImplyTitle;final Color? backgroundColor;final Border? border;final Brightness? brightness;Creates the mutable state for this widget at a given location in the tree.
+Subclasses should override this method to return a newly created +instance of their associated State subclass:
+@override
+State<SomeWidget> createState() => _SomeWidgetState();
+The framework can call this method multiple times over the lifetime of
+a StatefulWidget. For example, if the widget is inserted into the tree
+in multiple locations, the framework will create a separate State object
+for each location. Similarly, if the widget is removed from the tree and
+later inserted into the tree again, the framework will call createState
+again to create a fresh State object, simplifying the lifecycle of
+State objects.
@override
+State<UnselfSliverNavigationBar> createState() =>
+ _UnselfSliverNavigationBarState();final Object heroTag;final Widget? largeTitle;final Widget? leading;final Widget? middle;bool get opaque => backgroundColor?.alpha == 0xFF;final EdgeInsetsDirectional? padding;final String? previousPageTitle;final bool stretch;final Widget? trailing;final bool transitionBetweenRoutes;const HeroTag defaultHeroTag = HeroTag(null);Converts emoji to unicode 😀 => "1F600"
+String emojiToUnicode(String rawText) => _toCodePoint(
+ !rawText.contains(_u200D) ? rawText.replaceAll(_uFE0Fg, '') : rawText,
+ );Loads JPEG image and the FragmentProgram
+Future<ImageShader> loadImageShader(String assetString) async {
+ final asset = await rootBundle.load(assetString);
+ final image = await decodeImageFromList(asset.buffer.asUint8List());
+
+ return ImageShader(
+ image,
+ // Specify how image repetition is handled for x and y dimension
+ TileMode.repeated,
+ TileMode.repeated,
+ // Transformation matrix (identity matrix = no transformation)
+ Matrix4.identity().storage,
+ );
+}All emojis unicodes.
+for more details vist http://unicode.org/Public/emoji/12.0/emoji-test.txt
+// ignore_for_file: unnecessary_string_escapes
+
+final regex = RegExp(
+ '/\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67)\uDB40\uDC7F|(?:\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764(?:\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?|\u200D(?:\uD83D\uDC8B\u200D)?)\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69])|\uD83E\uDEF1\uD83C\uDFFF\u200D\uD83E\uDEF2)(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764(?:\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?|\u200D(?:\uD83D\uDC8B\u200D)?)\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69])|\uD83E\uDEF1\uD83C\uDFFE\u200D\uD83E\uDEF2)(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764(?:\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?|\u200D(?:\uD83D\uDC8B\u200D)?)\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69])|\uD83E\uDEF1\uD83C\uDFFD\u200D\uD83E\uDEF2)(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764(?:\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?|\u200D(?:\uD83D\uDC8B\u200D)?)\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69])|\uD83E\uDEF1\uD83C\uDFFC\u200D\uD83E\uDEF2)(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764(?:\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?|\u200D(?:\uD83D\uDC8B\u200D)?)\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69])|\uD83E\uDEF1\uD83C\uDFFB\u200D\uD83E\uDEF2)(?:\uD83C[\uDFFC-\uDFFF])|\uD83D\uDC68(?:\uD83C\uDFFB(?:\u200D(?:\u2764(?:\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])))|\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|[\u2695\u2696\u2708]\uFE0F|[\u2695\u2696\u2708]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))?|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764(?:\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])))|\u200D(?:\u2764(?:\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?|\u200D(?:\uD83D\uDC8B\u200D)?)\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])\uFE0F|\u200D(?:(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D[\uDC66\uDC67])|\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\u200D[\u2695\u2696\u2708])?|(?:\uD83D\uDC69(?:\uD83C\uDFFB\u200D\u2764(?:\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69]))|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764(?:\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])))|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC69(?:\u200D(?:\u2764(?:\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69]))|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83E\uDDD1(?:\u200D(?:\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F?\u200D\uD83D\uDDE8|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDE36\u200D\uD83C\uDF2B|\uD83C\uDFF3\uFE0F?\u200D\u26A7|\uD83D\uDC3B\u200D\u2744|(?:(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC6F|\uD83E[\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\u200D[\u2640\u2642])|\uD83C\uDFF4\u200D\u2620|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3C-\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])\u200D[\u2640\u2642]|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]|\uD83D[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3])\uFE0F|\uD83D\uDC41\uFE0F?\u200D\uD83D\uDDE8|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83C\uDFF3\uFE0F?\u200D\uD83C\uDF08|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDE36\u200D\uD83C\uDF2B|\uD83C\uDFF3\uFE0F?\u200D\u26A7|\uD83D\uDE35\u200D\uD83D\uDCAB|\uD83D\uDE2E\u200D\uD83D\uDCA8|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83E\uDEF1(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83E\uDDD1(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83D\uDC69(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83D\uDC3B\u200D\u2744|(?:(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC6F|\uD83E[\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\u200D[\u2640\u2642])|\uD83C\uDFF4\u200D\u2620|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF6\uD83C\uDDE6|\uD83C\uDDF4\uD83C\uDDF2|\uD83D\uDC08\u200D\u2B1B|\u2764(?:\uFE0F\u200D(?:\uD83D\uDD25|\uD83E\uDE79)|\u200D(?:\uD83D\uDD25|\uD83E\uDE79))|\uD83D\uDC41\uFE0F?|\uD83C\uDFF3\uFE0F?|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3C-\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])\u200D[\u2640\u2642]|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|[#\*0-9]\uFE0F?\u20E3|\uD83E\uDD3C(?:\uD83C[\uDFFB-\uDFFF])|\u2764\uFE0F?|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|\uD83C\uDFF4|(?:[\u270A\u270B]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF6])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270C\u270D]|\uD83D[\uDD74\uDD90])(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])|[\u261D\u270A-\u270D]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC08\uDC15\uDC3B\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD74\uDD7A\uDD90\uDD95\uDD96\uDE2E\uDE35\uDE36\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD3C\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF6]|\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD]|\uD83D\uDC6F|\uD83E[\uDDDE\uDDDF]|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]|\uD83D[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\uD83C[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDD-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uD83E[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE74\uDE78-\uDE7C\uDE80-\uDE86\uDE90-\uDEAC\uDEB0-\uDEBA\uDEC0-\uDEC2\uDED0-\uDED9\uDEE0-\uDEE7]',
+);void show({
+ required BuildContext context,
+ required WidgetBuilder builder,
+}) =>
+ Navigator.of(context).push(MaterialPageRoute(
+ builder: (BuildContext context) => builder(context),
+ ));HeroTag(null)
+ small, large, etc.).
+
+
+ void setThemeMode(ThemeMode themeMode);Stream<Settings> streamUser();const UserRepository();void dispose() => _controller.close();@override
+void setThemeMode(ThemeMode themeMode) =>
+ _controller.add(_currentUser.copyWith(themeMode: themeMode));@override
+Stream<Settings> streamUser() => _controller.stream;UngraphService({
+ required UngraphRepository repository,
+}) : _repo = repository {
+ _repo.watchTables().listen(_tables.add);
+}int get activeEdges => _edges.length;int get activeNodes => _nodes.length;FutureOr<void> clear() async =>
+ await Future.wait(_instanceSlug.toSet().map(dispose));Future<void> dispose(String instanceSlug) async {
+ _nodes.remove(instanceSlug);
+ _edges.remove(instanceSlug);
+}Future<EdgeService> edge(String specSlug) async =>
+ _edges[specSlug] ??= EdgeService(await _repo.initEdge(specSlug));Future<Set<String>> edgeOfNode(String specSlug) async =>
+ _nodesEdges[specSlug] ??= (await _repo.getEdgeOfNode(specSlug)).toSet();Future<NodeService> node(String specSlug) async =>
+ _nodes[specSlug] ??= NodeService(
+ await _repo.initNode(specSlug),
+ await edgeOfNode(specSlug),
+ );Future<void> registerEdge(EdgeSpec spec) async =>
+ await _repo.registerEdge(spec);Future<void> registerNode(NodeSpec spec) async =>
+ await _repo.registerNode(spec);\$EdgeSpecTable(this.attachedDatabase, [this._alias]);Tbl and can thus just return their instance.
+ STRICT.
+ LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ Uint8List. Example:
+ alias
+when used in a query.
+ BigInt.
+ enum class T.
+ companion to the real model class, D.
+ enum class T.
+ All columns from this table or view.
+@override
+List<GeneratedColumn> get \$columns =>
+ [id, name, slug, type, propSpecs, sourceNodeSpecId, targetNodeSpecId];The primary key of this table. Can be empty if no custom primary key has +been specified.
+Additional to the Table.primaryKey columns declared by an user, this +also contains auto-increment integers, which are primary key by default.
+@override
+Set<GeneratedColumn> get \$primaryKey => {id};The name of the table in the database. Unlike aliasedName, this can not +be aliased.
+@override
+String get actualTableName => 'edge_spec';The (potentially aliased) name of this table or view.
+If no alias is active, this is the same as entityName.
+@override
+String get aliasedName => _alias ?? 'edge_spec';The generated database instance that this view or table is attached to.
+@override
+final GeneratedDatabase attachedDatabase;Creates an alias of this table or view that will write the name alias
+when used in a query.
@override
+\$EdgeSpecTable createAlias(String alias) {
+ return \$EdgeSpecTable(attachedDatabase, alias);
+}@override
+late final GeneratedColumn<String> id = GeneratedColumn<String>(
+ 'id', aliasedName, false,
+ type: DriftSqlType.string,
+ requiredDuringInsert: false,
+ clientDefault: () => Slugid.nice().toString());Maps the given row returned by the database into the fitting data class.
+@override
+EdgeSpecData map(Map<String, dynamic> data, {String? tablePrefix}) {
+ final effectivePrefix = tablePrefix != null ? '\$tablePrefix.' : '';
+ return EdgeSpecData(
+ id: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}id'])!,
+ name: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}name'])!,
+ slug: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}slug'])!,
+ type: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}type'])!,
+ propSpecs: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}prop_specs'])!,
+ sourceNodeSpecId: attachedDatabase.typeMapping.read(
+ DriftSqlType.string, data['\${effectivePrefix}source_node_spec_id'])!,
+ targetNodeSpecId: attachedDatabase.typeMapping.read(
+ DriftSqlType.string, data['\${effectivePrefix}target_node_spec_id'])!,
+ );
+}@override
+late final GeneratedColumn<String> name = GeneratedColumn<String>(
+ 'name', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);@override
+late final GeneratedColumn<String> propSpecs = GeneratedColumn<String>(
+ 'prop_specs', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);@override
+late final GeneratedColumn<String> slug = GeneratedColumn<String>(
+ 'slug', aliasedName, false,
+ type: DriftSqlType.string,
+ requiredDuringInsert: true,
+ defaultConstraints: GeneratedColumn.constraintIsAlways('UNIQUE'));@override
+late final GeneratedColumn<String> sourceNodeSpecId = GeneratedColumn<String>(
+ 'source_node_spec_id', aliasedName, false,
+ type: DriftSqlType.string,
+ requiredDuringInsert: true,
+ defaultConstraints:
+ GeneratedColumn.constraintIsAlways('REFERENCES node_spec (slug)'));@override
+late final GeneratedColumn<String> targetNodeSpecId = GeneratedColumn<String>(
+ 'target_node_spec_id', aliasedName, false,
+ type: DriftSqlType.string,
+ requiredDuringInsert: true,
+ defaultConstraints:
+ GeneratedColumn.constraintIsAlways('REFERENCES node_spec (slug)'));@override
+late final GeneratedColumn<String> type = GeneratedColumn<String>(
+ 'type', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);Validates that the given entity can be inserted into this table, meaning +that it respects all constraints (nullability, text length, etc.).
+@override
+VerificationContext validateIntegrity(Insertable<EdgeSpecData> instance,
+ {bool isInserting = false}) {
+ final context = VerificationContext();
+ final data = instance.toColumns(true);
+ if (data.containsKey('id')) {
+ context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
+ }
+ if (data.containsKey('name')) {
+ context.handle(
+ _nameMeta, name.isAcceptableOrUnknown(data['name']!, _nameMeta));
+ } else if (isInserting) {
+ context.missing(_nameMeta);
+ }
+ if (data.containsKey('slug')) {
+ context.handle(
+ _slugMeta, slug.isAcceptableOrUnknown(data['slug']!, _slugMeta));
+ } else if (isInserting) {
+ context.missing(_slugMeta);
+ }
+ if (data.containsKey('type')) {
+ context.handle(
+ _typeMeta, type.isAcceptableOrUnknown(data['type']!, _typeMeta));
+ } else if (isInserting) {
+ context.missing(_typeMeta);
+ }
+ if (data.containsKey('prop_specs')) {
+ context.handle(_propSpecsMeta,
+ propSpecs.isAcceptableOrUnknown(data['prop_specs']!, _propSpecsMeta));
+ } else if (isInserting) {
+ context.missing(_propSpecsMeta);
+ }
+ if (data.containsKey('source_node_spec_id')) {
+ context.handle(
+ _sourceNodeSpecIdMeta,
+ sourceNodeSpecId.isAcceptableOrUnknown(
+ data['source_node_spec_id']!, _sourceNodeSpecIdMeta));
+ } else if (isInserting) {
+ context.missing(_sourceNodeSpecIdMeta);
+ }
+ if (data.containsKey('target_node_spec_id')) {
+ context.handle(
+ _targetNodeSpecIdMeta,
+ targetNodeSpecId.isAcceptableOrUnknown(
+ data['target_node_spec_id']!, _targetNodeSpecIdMeta));
+ } else if (isInserting) {
+ context.missing(_targetNodeSpecIdMeta);
+ }
+ return context;
+}\$NodeSpecTable(this.attachedDatabase, [this._alias]);Tbl and can thus just return their instance.
+ STRICT.
+ LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ Uint8List. Example:
+ alias
+when used in a query.
+ BigInt.
+ enum class T.
+ companion to the real model class, D.
+ enum class T.
+ All columns from this table or view.
+@override
+List<GeneratedColumn> get \$columns => [id, name, slug, labels, propSpecs];The primary key of this table. Can be empty if no custom primary key has +been specified.
+Additional to the Table.primaryKey columns declared by an user, this +also contains auto-increment integers, which are primary key by default.
+@override
+Set<GeneratedColumn> get \$primaryKey => {id};The name of the table in the database. Unlike aliasedName, this can not +be aliased.
+@override
+String get actualTableName => 'node_spec';The (potentially aliased) name of this table or view.
+If no alias is active, this is the same as entityName.
+@override
+String get aliasedName => _alias ?? 'node_spec';The generated database instance that this view or table is attached to.
+@override
+final GeneratedDatabase attachedDatabase;Creates an alias of this table or view that will write the name alias
+when used in a query.
@override
+\$NodeSpecTable createAlias(String alias) {
+ return \$NodeSpecTable(attachedDatabase, alias);
+}@override
+late final GeneratedColumn<String> id = GeneratedColumn<String>(
+ 'id', aliasedName, false,
+ type: DriftSqlType.string,
+ requiredDuringInsert: false,
+ clientDefault: () => Slugid.nice().toString());@override
+late final GeneratedColumn<String> labels = GeneratedColumn<String>(
+ 'labels', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);Maps the given row returned by the database into the fitting data class.
+@override
+NodeSpecData map(Map<String, dynamic> data, {String? tablePrefix}) {
+ final effectivePrefix = tablePrefix != null ? '\$tablePrefix.' : '';
+ return NodeSpecData(
+ id: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}id'])!,
+ name: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}name'])!,
+ slug: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}slug'])!,
+ labels: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}labels'])!,
+ propSpecs: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}prop_specs'])!,
+ );
+}@override
+late final GeneratedColumn<String> name = GeneratedColumn<String>(
+ 'name', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);@override
+late final GeneratedColumn<String> propSpecs = GeneratedColumn<String>(
+ 'prop_specs', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);@override
+late final GeneratedColumn<String> slug = GeneratedColumn<String>(
+ 'slug', aliasedName, false,
+ type: DriftSqlType.string,
+ requiredDuringInsert: true,
+ defaultConstraints: GeneratedColumn.constraintIsAlways('UNIQUE'));Validates that the given entity can be inserted into this table, meaning +that it respects all constraints (nullability, text length, etc.).
+@override
+VerificationContext validateIntegrity(Insertable<NodeSpecData> instance,
+ {bool isInserting = false}) {
+ final context = VerificationContext();
+ final data = instance.toColumns(true);
+ if (data.containsKey('id')) {
+ context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
+ }
+ if (data.containsKey('name')) {
+ context.handle(
+ _nameMeta, name.isAcceptableOrUnknown(data['name']!, _nameMeta));
+ } else if (isInserting) {
+ context.missing(_nameMeta);
+ }
+ if (data.containsKey('slug')) {
+ context.handle(
+ _slugMeta, slug.isAcceptableOrUnknown(data['slug']!, _slugMeta));
+ } else if (isInserting) {
+ context.missing(_slugMeta);
+ }
+ if (data.containsKey('labels')) {
+ context.handle(_labelsMeta,
+ labels.isAcceptableOrUnknown(data['labels']!, _labelsMeta));
+ } else if (isInserting) {
+ context.missing(_labelsMeta);
+ }
+ if (data.containsKey('prop_specs')) {
+ context.handle(_propSpecsMeta,
+ propSpecs.isAcceptableOrUnknown(data['prop_specs']!, _propSpecsMeta));
+ } else if (isInserting) {
+ context.missing(_propSpecsMeta);
+ }
+ return context;
+}\$UnpackSpecTable(this.attachedDatabase, [this._alias]);Tbl and can thus just return their instance.
+ STRICT.
+ LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ Uint8List. Example:
+ alias
+when used in a query.
+ BigInt.
+ enum class T.
+ companion to the real model class, D.
+ enum class T.
+ All columns from this table or view.
+@override
+List<GeneratedColumn> get \$columns =>
+ [id, slug, name, fileSpec, retrieveSpec, modules];The primary key of this table. Can be empty if no custom primary key has +been specified.
+Additional to the Table.primaryKey columns declared by an user, this +also contains auto-increment integers, which are primary key by default.
+@override
+Set<GeneratedColumn> get \$primaryKey => {id};The name of the table in the database. Unlike aliasedName, this can not +be aliased.
+@override
+String get actualTableName => 'unpack_spec';The (potentially aliased) name of this table or view.
+If no alias is active, this is the same as entityName.
+@override
+String get aliasedName => _alias ?? 'unpack_spec';The generated database instance that this view or table is attached to.
+@override
+final GeneratedDatabase attachedDatabase;Creates an alias of this table or view that will write the name alias
+when used in a query.
@override
+\$UnpackSpecTable createAlias(String alias) {
+ return \$UnpackSpecTable(attachedDatabase, alias);
+}@override
+late final GeneratedColumn<String> fileSpec = GeneratedColumn<String>(
+ 'file_spec', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);@override
+late final GeneratedColumn<String> id = GeneratedColumn<String>(
+ 'id', aliasedName, false,
+ type: DriftSqlType.string,
+ requiredDuringInsert: false,
+ clientDefault: () => Slugid.nice().toString());Maps the given row returned by the database into the fitting data class.
+@override
+UnpackSpecData map(Map<String, dynamic> data, {String? tablePrefix}) {
+ final effectivePrefix = tablePrefix != null ? '\$tablePrefix.' : '';
+ return UnpackSpecData(
+ id: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}id'])!,
+ slug: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}slug'])!,
+ name: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}name'])!,
+ fileSpec: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}file_spec'])!,
+ retrieveSpec: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}retrieve_spec'])!,
+ modules: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}modules'])!,
+ );
+}@override
+late final GeneratedColumn<String> modules = GeneratedColumn<String>(
+ 'modules', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);@override
+late final GeneratedColumn<String> name = GeneratedColumn<String>(
+ 'name', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);@override
+late final GeneratedColumn<String> retrieveSpec = GeneratedColumn<String>(
+ 'retrieve_spec', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);@override
+late final GeneratedColumn<String> slug = GeneratedColumn<String>(
+ 'slug', aliasedName, false,
+ type: DriftSqlType.string,
+ requiredDuringInsert: true,
+ defaultConstraints: GeneratedColumn.constraintIsAlways('UNIQUE'));Validates that the given entity can be inserted into this table, meaning +that it respects all constraints (nullability, text length, etc.).
+@override
+VerificationContext validateIntegrity(Insertable<UnpackSpecData> instance,
+ {bool isInserting = false}) {
+ final context = VerificationContext();
+ final data = instance.toColumns(true);
+ if (data.containsKey('id')) {
+ context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
+ }
+ if (data.containsKey('slug')) {
+ context.handle(
+ _slugMeta, slug.isAcceptableOrUnknown(data['slug']!, _slugMeta));
+ } else if (isInserting) {
+ context.missing(_slugMeta);
+ }
+ if (data.containsKey('name')) {
+ context.handle(
+ _nameMeta, name.isAcceptableOrUnknown(data['name']!, _nameMeta));
+ } else if (isInserting) {
+ context.missing(_nameMeta);
+ }
+ if (data.containsKey('file_spec')) {
+ context.handle(_fileSpecMeta,
+ fileSpec.isAcceptableOrUnknown(data['file_spec']!, _fileSpecMeta));
+ } else if (isInserting) {
+ context.missing(_fileSpecMeta);
+ }
+ if (data.containsKey('retrieve_spec')) {
+ context.handle(
+ _retrieveSpecMeta,
+ retrieveSpec.isAcceptableOrUnknown(
+ data['retrieve_spec']!, _retrieveSpecMeta));
+ } else if (isInserting) {
+ context.missing(_retrieveSpecMeta);
+ }
+ if (data.containsKey('modules')) {
+ context.handle(_modulesMeta,
+ modules.isAcceptableOrUnknown(data['modules']!, _modulesMeta));
+ } else if (isInserting) {
+ context.missing(_modulesMeta);
+ }
+ return context;
+}\$UnpackStateTable(this.attachedDatabase, [this._alias]);Tbl and can thus just return their instance.
+ STRICT.
+ LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ Uint8List. Example:
+ alias
+when used in a query.
+ BigInt.
+ enum class T.
+ companion to the real model class, D.
+ enum class T.
+ All columns from this table or view.
+@override
+List<GeneratedColumn> get \$columns =>
+ [id, specId, step, selectedModules, filePath];The primary key of this table. Can be empty if no custom primary key has +been specified.
+Additional to the Table.primaryKey columns declared by an user, this +also contains auto-increment integers, which are primary key by default.
+@override
+Set<GeneratedColumn> get \$primaryKey => {id};The name of the table in the database. Unlike aliasedName, this can not +be aliased.
+@override
+String get actualTableName => 'unpack_state';The (potentially aliased) name of this table or view.
+If no alias is active, this is the same as entityName.
+@override
+String get aliasedName => _alias ?? 'unpack_state';The generated database instance that this view or table is attached to.
+@override
+final GeneratedDatabase attachedDatabase;Creates an alias of this table or view that will write the name alias
+when used in a query.
@override
+\$UnpackStateTable createAlias(String alias) {
+ return \$UnpackStateTable(attachedDatabase, alias);
+}@override
+late final GeneratedColumn<String> filePath = GeneratedColumn<String>(
+ 'file_path', aliasedName, true,
+ type: DriftSqlType.string, requiredDuringInsert: false);@override
+late final GeneratedColumn<String> id = GeneratedColumn<String>(
+ 'id', aliasedName, false,
+ type: DriftSqlType.string,
+ requiredDuringInsert: false,
+ clientDefault: () => Slugid.nice().toString());Maps the given row returned by the database into the fitting data class.
+@override
+UnpackStateData map(Map<String, dynamic> data, {String? tablePrefix}) {
+ final effectivePrefix = tablePrefix != null ? '\$tablePrefix.' : '';
+ return UnpackStateData(
+ id: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}id'])!,
+ specId: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}spec_id'])!,
+ step: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}step'])!,
+ selectedModules: attachedDatabase.typeMapping.read(
+ DriftSqlType.string, data['\${effectivePrefix}selected_modules']),
+ filePath: attachedDatabase.typeMapping
+ .read(DriftSqlType.string, data['\${effectivePrefix}file_path']),
+ );
+}@override
+late final GeneratedColumn<String> selectedModules = GeneratedColumn<String>(
+ 'selected_modules', aliasedName, true,
+ type: DriftSqlType.string, requiredDuringInsert: false);@override
+late final GeneratedColumn<String> specId = GeneratedColumn<String>(
+ 'spec_id', aliasedName, false,
+ type: DriftSqlType.string,
+ requiredDuringInsert: true,
+ defaultConstraints:
+ GeneratedColumn.constraintIsAlways('REFERENCES unpack_spec (id)'));@override
+late final GeneratedColumn<String> step = GeneratedColumn<String>(
+ 'step', aliasedName, false,
+ type: DriftSqlType.string, requiredDuringInsert: true);Validates that the given entity can be inserted into this table, meaning +that it respects all constraints (nullability, text length, etc.).
+@override
+VerificationContext validateIntegrity(Insertable<UnpackStateData> instance,
+ {bool isInserting = false}) {
+ final context = VerificationContext();
+ final data = instance.toColumns(true);
+ if (data.containsKey('id')) {
+ context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
+ }
+ if (data.containsKey('spec_id')) {
+ context.handle(_specIdMeta,
+ specId.isAcceptableOrUnknown(data['spec_id']!, _specIdMeta));
+ } else if (isInserting) {
+ context.missing(_specIdMeta);
+ }
+ if (data.containsKey('step')) {
+ context.handle(
+ _stepMeta, step.isAcceptableOrUnknown(data['step']!, _stepMeta));
+ } else if (isInserting) {
+ context.missing(_stepMeta);
+ }
+ if (data.containsKey('selected_modules')) {
+ context.handle(
+ _selectedModulesMeta,
+ selectedModules.isAcceptableOrUnknown(
+ data['selected_modules']!, _selectedModulesMeta));
+ }
+ if (data.containsKey('file_path')) {
+ context.handle(_filePathMeta,
+ filePath.isAcceptableOrUnknown(data['file_path']!, _filePathMeta));
+ }
+ return context;
+}factory DynamicColumn(
+ String name,
+ String tableName,
+ bool nullable,
+) =>
+ DynamicColumn._(
+ name,
+ tableName,
+ nullable,
+ type: DriftSqlType.forType(),
+ );CHECK column constraint present on this column.
+ AUTOINCREMENT primary key constraint that was
+created by drift.
+ CASE WHEN construct using the current expression as a base.
+ CAST(expression AS TYPE) expression.
+ D.
+ compare value will be written
+as a variable using prepared statements, so there is no risk of
+an SQL-injection.
+ compare or null.
+ this if predicate is true, otherwise evaluates to ifFalse.
+ IS expression in SQL, comparing this expression with the
+other expression.
+ this resolves to any of the values in
+values.
+ this is included in any row of the
+provided select statement.
+ IS NOT expression in SQL, comparing this expression with
+the other expression.
+ this does not resolve to any of the values
+in values.
+ this is not included in any row of the
+provided select statement.
+ IS NOT expression in SQL, comparing this expression with
+the Dart value.
+ IS expression in SQL, comparing this expression with the
+Dart value.
+ null if matcher is equal to this expression, this otherwise.
+ precedence. If the Expression.precedence of
+this expression is lower, it will be wrap}ped in
+ inner expression, this utility method can
+be used inside writeInto to write that inner expression while wrapping
+it in parentheses if necessary.
+ context by writing to its
+GenerationContext.buffer or by introducing bound variables. When writing
+into the buffer, no whitespace around the this component should be
+introduced. When a component consists of multiple composed component, it's
+responsible for introducing whitespace between its child components.
+ static fromString(
+ String name,
+ String tableName,
+ bool nullable, {
+ required String type,
+}) =>
+ DynamicColumn._(
+ name,
+ tableName,
+ nullable,
+ type: DriftSqlType.values.singleWhere((e) => e.name == type),
+ );DynamicDao(super.attachedDatabase);VALUES for an insert statement.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and SelectableUtils.watchSingle which return the item
+directly without wrapping it into a list.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and watchSingle which return the item directly without
+wrapping it into a list.
+ statement on the database.
+ updates parameter so that drift knows which tables are
+affected by your query. All select streams that depend on a table
+specified there will then update their data. For more accurate results,
+you can also set the updateKind parameter to UpdateKind.delete or
+UpdateKind.update. This is optional, but can improve the accuracy of
+query updates, especially when using triggers.
+ INSERT, UPDATE or DELETE statement returning rows.
+ fn after this executor is ready, or directly if it's
+already ready.
+ table by using InsertStatement.insert.
+ tables as updated.
+ updates to the stream query manager.
+ table that doesn't necessarily use all of
+table's columns.
+ action in a transaction, which means that all its queries and
+updates will be called atomically.
+ Future<void> createTable() async =>
+ // ignore: invalid_use_of_visible_for_testing_member, invalid_use_of_protected_member
+ await attachedDatabase.createMigrator().createTable(table);DynamicTable get table;DynamicData(this.data);serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
+ serializer can be
+used to configure how individual values will be encoded. By default,
+DriftRuntimeOptions.defaultSerializer will be used. See
+ValueSerializer.defaults for details.
+ final Map<String, dynamic> data;Converts this object into a map of column names to expressions to insert +or update.
+Note that the keys in the map are the raw column names, they're not +escaped.
+The nullToAbsent can be used on DataClasses to control whether null
+fields should be set to a null constant in sql or absent from the map.
+Other implementations ignore that nullToAbsent, it mainly exists for
+legacy reasons.
@override
+Map<String, Expression<Object>> toColumns(bool nullToAbsent) =>
+ data.map((k, v) => MapEntry(k, Variable(v)))
+ ..putIfAbsent('id', () => Variable(Slugid.nice().toString()));Converts this object into a representation that can be encoded with
+json. The serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
@override
+// TODO: implement toJson
+Map<String, dynamic> toJson({ValueSerializer? serializer}) =>
+ throw UnimplementedError();A string representation of this object.
+Some classes have a default textual representation,
+often paired with a static parse function (like int.parse).
+These classes will provide the textual representation as
+their string representation.
Other classes have no meaningful textual representation
+that a program will care about.
+Such classes will typically override toString to provide
+useful information when inspecting the object,
+mainly for debugging or logging.
@override
+String toString() => data.toString();DynamicDatabase(super.attachedDatabase);VALUES for an insert statement.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and SelectableUtils.watchSingle which return the item
+directly without wrapping it into a list.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and watchSingle which return the item directly without
+wrapping it into a list.
+ statement on the database.
+ updates parameter so that drift knows which tables are
+affected by your query. All select streams that depend on a table
+specified there will then update their data. For more accurate results,
+you can also set the updateKind parameter to UpdateKind.delete or
+UpdateKind.update. This is optional, but can improve the accuracy of
+query updates, especially when using triggers.
+ INSERT, UPDATE or DELETE statement returning rows.
+ fn after this executor is ready, or directly if it's
+already ready.
+ table by using InsertStatement.insert.
+ tables as updated.
+ updates to the stream query manager.
+ table that doesn't necessarily use all of
+table's columns.
+ action in a transaction, which means that all its queries and
+updates will be called atomically.
+ static const query = {
+ 'queryTables': '''
+SELECT
+ name
+FROM
+ sqlite_master
+WHERE
+ type = 'table' AND
+ name NOT LIKE 'sqlite_%';
+'''
+};Selectable<String> queryTables() {
+ return customSelect(
+ 'SELECT name FROM sqlite_master WHERE type = \'table\' AND name NOT LIKE \'sqlite_%\'',
+ variables: [],
+ readsFrom: {}).map((QueryRow row) => row.read<String>('name'));
+}Future<Iterable<String>> realTables() => queryTables().get();late final Set<String> staticTables =
+ attachedDatabase.allTables.map((e) => e.actualTableName).toSet();Future<Iterable<String>> tables() =>
+ queryTables().get().then((tables) => tables.where(
+ (table) => !staticTables.contains(table),
+ ));All columns from this table or view.
+@override
+final List<GeneratedColumn> \$columns;DynamicTable(
+ // this.actualTableName,
+ this.\$columns, {
+ String? alias,
+ UngraphDatabase? attachedDatabase,
+}) : _alias = alias,
+ _attachedDatabase = attachedDatabase;Tbl and can thus just return their instance.
+ STRICT.
+ LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ Uint8List. Example:
+ alias
+when used in a query.
+ BigInt.
+ enum class T.
+ companion to the real model class, D.
+ enum class T.
+ The name of the table in the database. Unlike aliasedName, this can not +be aliased.
+@override
+String get actualTableName;The (potentially aliased) name of this table or view.
+If no alias is active, this is the same as entityName.
+@override
+String get aliasedName => _alias ?? actualTableName;void attach(UngraphDatabase database) => this._attachedDatabase = database;The generated database instance that this view or table is attached to.
+@override
+UngraphDatabase get attachedDatabase {
+ if (_attachedDatabase != null) return _attachedDatabase!;
+ throw StateError('Database is not yet attached for DynamicTables.');
+}Future<void> createTable() async =>
+ // ignore: invalid_use_of_visible_for_testing_member, invalid_use_of_protected_member
+ await attachedDatabase.createMigrator().createTable(this);EdgeDao(this.table, [UngraphDatabase? db])
+ : super(db ?? table.attachedDatabase);VALUES for an insert statement.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and SelectableUtils.watchSingle which return the item
+directly without wrapping it into a list.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and watchSingle which return the item directly without
+wrapping it into a list.
+ statement on the database.
+ updates parameter so that drift knows which tables are
+affected by your query. All select streams that depend on a table
+specified there will then update their data. For more accurate results,
+you can also set the updateKind parameter to UpdateKind.delete or
+UpdateKind.update. This is optional, but can improve the accuracy of
+query updates, especially when using triggers.
+ INSERT, UPDATE or DELETE statement returning rows.
+ fn after this executor is ready, or directly if it's
+already ready.
+ table by using InsertStatement.insert.
+ tables as updated.
+ updates to the stream query manager.
+ table that doesn't necessarily use all of
+table's columns.
+ action in a transaction, which means that all its queries and
+updates will be called atomically.
+ Future<List<EdgeData>> getAll() => select(table).get();@override
+final EdgeTable table;EdgeData(this.specSlug, super.data);serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
+ serializer can be
+used to configure how individual values will be encoded. By default,
+DriftRuntimeOptions.defaultSerializer will be used. See
+ValueSerializer.defaults for details.
+ final String specSlug;STRICT.
+ LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ Uint8List. Example:
+ BigInt.
+ enum class T.
+ enum class T.
+ TextColumn get name => text()();TextColumn get propSpecs => text()();TextColumn get slug => text().unique()();TextColumn get sourceNodeSpecId => text().references(NodeSpec, #slug)();TextColumn get targetNodeSpecId => text().references(NodeSpec, #slug)();TextColumn get type => text()();const EdgeSpecCompanion({
+ this.id = const Value.absent(),
+ this.name = const Value.absent(),
+ this.slug = const Value.absent(),
+ this.type = const Value.absent(),
+ this.propSpecs = const Value.absent(),
+ this.sourceNodeSpecId = const Value.absent(),
+ this.targetNodeSpecId = const Value.absent(),
+ this.rowid = const Value.absent(),
+});EdgeSpecCompanion copyWith(
+ {Value<String>? id,
+ Value<String>? name,
+ Value<String>? slug,
+ Value<String>? type,
+ Value<String>? propSpecs,
+ Value<String>? sourceNodeSpecId,
+ Value<String>? targetNodeSpecId,
+ Value<int>? rowid}) {
+ return EdgeSpecCompanion(
+ id: id ?? this.id,
+ name: name ?? this.name,
+ slug: slug ?? this.slug,
+ type: type ?? this.type,
+ propSpecs: propSpecs ?? this.propSpecs,
+ sourceNodeSpecId: sourceNodeSpecId ?? this.sourceNodeSpecId,
+ targetNodeSpecId: targetNodeSpecId ?? this.targetNodeSpecId,
+ rowid: rowid ?? this.rowid,
+ );
+}static Insertable<EdgeSpecData> custom({
+ Expression<String>? id,
+ Expression<String>? name,
+ Expression<String>? slug,
+ Expression<String>? type,
+ Expression<String>? propSpecs,
+ Expression<String>? sourceNodeSpecId,
+ Expression<String>? targetNodeSpecId,
+ Expression<int>? rowid,
+}) {
+ return RawValuesInsertable({
+ if (id != null) 'id': id,
+ if (name != null) 'name': name,
+ if (slug != null) 'slug': slug,
+ if (type != null) 'type': type,
+ if (propSpecs != null) 'prop_specs': propSpecs,
+ if (sourceNodeSpecId != null) 'source_node_spec_id': sourceNodeSpecId,
+ if (targetNodeSpecId != null) 'target_node_spec_id': targetNodeSpecId,
+ if (rowid != null) 'rowid': rowid,
+ });
+}final Value<String> id;final Value<String> name;final Value<String> propSpecs;final Value<int> rowid;final Value<String> slug;final Value<String> sourceNodeSpecId;final Value<String> targetNodeSpecId;Converts this object into a map of column names to expressions to insert +or update.
+Note that the keys in the map are the raw column names, they're not +escaped.
+The nullToAbsent can be used on DataClasses to control whether null
+fields should be set to a null constant in sql or absent from the map.
+Other implementations ignore that nullToAbsent, it mainly exists for
+legacy reasons.
@override
+Map<String, Expression> toColumns(bool nullToAbsent) {
+ final map = <String, Expression>{};
+ if (id.present) {
+ map['id'] = Variable<String>(id.value);
+ }
+ if (name.present) {
+ map['name'] = Variable<String>(name.value);
+ }
+ if (slug.present) {
+ map['slug'] = Variable<String>(slug.value);
+ }
+ if (type.present) {
+ map['type'] = Variable<String>(type.value);
+ }
+ if (propSpecs.present) {
+ map['prop_specs'] = Variable<String>(propSpecs.value);
+ }
+ if (sourceNodeSpecId.present) {
+ map['source_node_spec_id'] = Variable<String>(sourceNodeSpecId.value);
+ }
+ if (targetNodeSpecId.present) {
+ map['target_node_spec_id'] = Variable<String>(targetNodeSpecId.value);
+ }
+ if (rowid.present) {
+ map['rowid'] = Variable<int>(rowid.value);
+ }
+ return map;
+}A string representation of this object.
+Some classes have a default textual representation,
+often paired with a static parse function (like int.parse).
+These classes will provide the textual representation as
+their string representation.
Other classes have no meaningful textual representation
+that a program will care about.
+Such classes will typically override toString to provide
+useful information when inspecting the object,
+mainly for debugging or logging.
@override
+String toString() {
+ return (StringBuffer('EdgeSpecCompanion(')
+ ..write('id: \$id, ')
+ ..write('name: \$name, ')
+ ..write('slug: \$slug, ')
+ ..write('type: \$type, ')
+ ..write('propSpecs: \$propSpecs, ')
+ ..write('sourceNodeSpecId: \$sourceNodeSpecId, ')
+ ..write('targetNodeSpecId: \$targetNodeSpecId, ')
+ ..write('rowid: \$rowid')
+ ..write(')'))
+ .toString();
+}final Value<String> type;EdgeSpecDao(super.attachedDatabase);VALUES for an insert statement.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and SelectableUtils.watchSingle which return the item
+directly without wrapping it into a list.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and watchSingle which return the item directly without
+wrapping it into a list.
+ statement on the database.
+ updates parameter so that drift knows which tables are
+affected by your query. All select streams that depend on a table
+specified there will then update their data. For more accurate results,
+you can also set the updateKind parameter to UpdateKind.delete or
+UpdateKind.update. This is optional, but can improve the accuracy of
+query updates, especially when using triggers.
+ INSERT, UPDATE or DELETE statement returning rows.
+ fn after this executor is ready, or directly if it's
+already ready.
+ table by using InsertStatement.insert.
+ tables as updated.
+ updates to the stream query manager.
+ table that doesn't necessarily use all of
+table's columns.
+ action in a transaction, which means that all its queries and
+updates will be called atomically.
+ Future<int> get count {
+ final countExp = edgeSpec.id.count();
+ final q = selectOnly(edgeSpec)..addColumns([countExp]);
+
+ return q.map((row) => row.read(countExp)).getSingle().then((_) => _!);
+}\$EdgeSpecTable get edgeSpec => attachedDatabase.edgeSpec;Future<EdgeSpecData> get(String id) {
+ final q = select(edgeSpec)..where((t) => t.id.equals(id));
+ return q.getSingle();
+}Future<List<EdgeSpecData>> getAll() => select(edgeSpec).get();Future<List<String>> getAllByNode(String slug) {
+ final q = select(edgeSpec)
+ ..where((t) =>
+ t.sourceNodeSpecId.equals(slug) | t.targetNodeSpecId.equals(slug));
+ return q.map((t) => t.slug).get();
+}Future<List<String>> getAllBySourceNode(Iterable<String> slugs) {
+ final q = select(edgeSpec)..where((t) => t.sourceNodeSpecId.isIn(slugs));
+ return q.map((t) => t.slug).get();
+}Future<List<String>> getAllByTargetNode(Iterable<String> slugs) {
+ final q = select(edgeSpec)..where((t) => t.targetNodeSpecId.isIn(slugs));
+ return q.map((t) => t.slug).get();
+}Future<EdgeSpecData> getBySlug(String slug) {
+ final q = select(edgeSpec)..where((t) => t.slug.equals(slug));
+ return q.getSingle();
+}Future<bool> get isEmpty => count.then((value) => value == 0);\$NodeSpecTable get nodeSpec => attachedDatabase.nodeSpec;Future<EdgeSpecData> put(Insertable<EdgeSpecData> entity) =>
+ into(edgeSpec).insertReturning(entity, mode: InsertMode.insertOrReplace);Future<void> putAll(Iterable<Insertable<EdgeSpecData>> entities) =>
+ batch((batch) => batch.insertAll(edgeSpec, entities,
+ mode: InsertMode.insertOrReplace));Stream<List<EdgeSpecData>> watchAll() => select(edgeSpec).watch();const EdgeSpecData(
+ {required this.id,
+ required this.name,
+ required this.slug,
+ required this.type,
+ required this.propSpecs,
+ required this.sourceNodeSpecId,
+ required this.targetNodeSpecId});json. The serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
+ serializer can be
+used to configure how individual values will be encoded. By default,
+DriftRuntimeOptions.defaultSerializer will be used. See
+ValueSerializer.defaults for details.
+ EdgeSpecData copyWith(
+ {String? id,
+ String? name,
+ String? slug,
+ String? type,
+ String? propSpecs,
+ String? sourceNodeSpecId,
+ String? targetNodeSpecId}) =>
+ EdgeSpecData(
+ id: id ?? this.id,
+ name: name ?? this.name,
+ slug: slug ?? this.slug,
+ type: type ?? this.type,
+ propSpecs: propSpecs ?? this.propSpecs,
+ sourceNodeSpecId: sourceNodeSpecId ?? this.sourceNodeSpecId,
+ targetNodeSpecId: targetNodeSpecId ?? this.targetNodeSpecId,
+ );The hash code for this object.
+A hash code is a single integer which represents the state of the object +that affects operator == comparisons.
+All objects have hash codes. +The default hash code implemented by Object +represents only the identity of the object, +the same way as the default operator == implementation only considers objects +equal if they are identical (see identityHashCode).
+If operator == is overridden to use the object state instead, +the hash code must also be changed to represent that state, +otherwise the object cannot be used in hash based data structures +like the default Set and Map implementations.
+Hash codes must be the same for objects that are equal to each other +according to operator ==. +The hash code of an object should only change if the object changes +in a way that affects equality. +There are no further requirements for the hash codes. +They need not be consistent between executions of the same program +and there are no distribution guarantees.
+Objects that are not equal are allowed to have the same hash code. +It is even technically allowed that all instances have the same hash code, +but if clashes happen too often, +it may reduce the efficiency of hash-based data structures +like HashSet or HashMap.
+If a subclass overrides hashCode, it should override the +operator == operator as well to maintain consistency.
+@override
+int get hashCode => Object.hash(
+ id, name, slug, type, propSpecs, sourceNodeSpecId, targetNodeSpecId);final String id;final String name;The equality operator.
+The default behavior for all Objects is to return true if and
+only if this object and other are the same object.
Override this method to specify a different equality relation on +a class. The overriding method must still be an equivalence relation. +That is, it must be:
+Total: It must return a boolean for all arguments. It should never throw.
+Reflexive: For all objects o, o == o must be true.
Symmetric: For all objects o1 and o2, o1 == o2 and o2 == o1 must
+either both be true, or both be false.
Transitive: For all objects o1, o2, and o3, if o1 == o2 and
+o2 == o3 are true, then o1 == o3 must be true.
The method should also be consistent over time, +so whether two objects are equal should only change +if at least one of the objects was modified.
+If a subclass overrides the equality operator, it should override +the hashCode method as well to maintain consistency.
+@override
+bool operator ==(Object other) =>
+ identical(this, other) ||
+ (other is EdgeSpecData &&
+ other.id == this.id &&
+ other.name == this.name &&
+ other.slug == this.slug &&
+ other.type == this.type &&
+ other.propSpecs == this.propSpecs &&
+ other.sourceNodeSpecId == this.sourceNodeSpecId &&
+ other.targetNodeSpecId == this.targetNodeSpecId);final String propSpecs;final String slug;final String sourceNodeSpecId;final String targetNodeSpecId;Converts this object into a map of column names to expressions to insert +or update.
+Note that the keys in the map are the raw column names, they're not +escaped.
+The nullToAbsent can be used on DataClasses to control whether null
+fields should be set to a null constant in sql or absent from the map.
+Other implementations ignore that nullToAbsent, it mainly exists for
+legacy reasons.
@override
+Map<String, Expression> toColumns(bool nullToAbsent) {
+ final map = <String, Expression>{};
+ map['id'] = Variable<String>(id);
+ map['name'] = Variable<String>(name);
+ map['slug'] = Variable<String>(slug);
+ map['type'] = Variable<String>(type);
+ map['prop_specs'] = Variable<String>(propSpecs);
+ map['source_node_spec_id'] = Variable<String>(sourceNodeSpecId);
+ map['target_node_spec_id'] = Variable<String>(targetNodeSpecId);
+ return map;
+}EdgeSpecCompanion toCompanion(bool nullToAbsent) {
+ return EdgeSpecCompanion(
+ id: Value(id),
+ name: Value(name),
+ slug: Value(slug),
+ type: Value(type),
+ propSpecs: Value(propSpecs),
+ sourceNodeSpecId: Value(sourceNodeSpecId),
+ targetNodeSpecId: Value(targetNodeSpecId),
+ );
+}Converts this object into a representation that can be encoded with
+json. The serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
@override
+Map<String, dynamic> toJson({ValueSerializer? serializer}) {
+ serializer ??= driftRuntimeOptions.defaultSerializer;
+ return <String, dynamic>{
+ 'id': serializer.toJson<String>(id),
+ 'name': serializer.toJson<String>(name),
+ 'slug': serializer.toJson<String>(slug),
+ 'type': serializer.toJson<String>(type),
+ 'propSpecs': serializer.toJson<String>(propSpecs),
+ 'sourceNodeSpecId': serializer.toJson<String>(sourceNodeSpecId),
+ 'targetNodeSpecId': serializer.toJson<String>(targetNodeSpecId),
+ };
+}A string representation of this object.
+Some classes have a default textual representation,
+often paired with a static parse function (like int.parse).
+These classes will provide the textual representation as
+their string representation.
Other classes have no meaningful textual representation
+that a program will care about.
+Such classes will typically override toString to provide
+useful information when inspecting the object,
+mainly for debugging or logging.
@override
+String toString() {
+ return (StringBuffer('EdgeSpecData(')
+ ..write('id: \$id, ')
+ ..write('name: \$name, ')
+ ..write('slug: \$slug, ')
+ ..write('type: \$type, ')
+ ..write('propSpecs: \$propSpecs, ')
+ ..write('sourceNodeSpecId: \$sourceNodeSpecId, ')
+ ..write('targetNodeSpecId: \$targetNodeSpecId')
+ ..write(')'))
+ .toString();
+}final String type;EdgeTable(
+ this.specId,
+ this.specSlug,
+ super.\$columns, {
+ super.alias,
+ super.attachedDatabase,
+});Tbl and can thus just return their instance.
+ STRICT.
+ LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ Uint8List. Example:
+ alias
+when used in a query.
+ BigInt.
+ enum class T.
+ companion to the real model class, D.
+ enum class T.
+ The name of the table in the database. Unlike aliasedName, this can not +be aliased.
+@override
+String get actualTableName => specSlug;Creates an alias of this table or view that will write the name alias
+when used in a query.
@override
+EdgeTable createAlias(String alias) => EdgeTable(
+ specId,
+ specSlug,
+ \$columns,
+ alias: alias,
+ attachedDatabase: attachedDatabase,
+ );Maps the given row returned by the database into the fitting data class.
+@override
+FutureOr<EdgeData> map(Map<String, dynamic> data, {String? tablePrefix}) =>
+ EdgeData(specSlug, data);final String specId;final String specSlug;Maps a column from the database back to Dart.
+@override
+List<T> fromSql(String fromDb) => List<T>.from(jsonDecode(fromDb) ?? []);Map a value from an object in Dart into something that will be understood +by the database.
+@override
+String toSql(List<T> value) => jsonEncode(value);Maps a column from the database back to Dart.
+@override
+Map<String, T> fromSql(String fromDb) =>
+ Map<String, T>.from(jsonDecode(fromDb) ?? {});Map a value from an object in Dart into something that will be understood +by the database.
+@override
+String toSql(Map<String, T> value) => jsonEncode(value);NodeDao(this.table, [UngraphDatabase? db])
+ : super(db ?? table.attachedDatabase);VALUES for an insert statement.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and SelectableUtils.watchSingle which return the item
+directly without wrapping it into a list.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and watchSingle which return the item directly without
+wrapping it into a list.
+ statement on the database.
+ updates parameter so that drift knows which tables are
+affected by your query. All select streams that depend on a table
+specified there will then update their data. For more accurate results,
+you can also set the updateKind parameter to UpdateKind.delete or
+UpdateKind.update. This is optional, but can improve the accuracy of
+query updates, especially when using triggers.
+ INSERT, UPDATE or DELETE statement returning rows.
+ fn after this executor is ready, or directly if it's
+already ready.
+ table by using InsertStatement.insert.
+ tables as updated.
+ updates to the stream query manager.
+ table that doesn't necessarily use all of
+table's columns.
+ action in a transaction, which means that all its queries and
+updates will be called atomically.
+ Future<List<NodeData>> getAll() => select(table).get();Future<NodeData> put(Insertable<NodeData> entity) =>
+ into(table).insertReturning(entity, mode: InsertMode.insertOrReplace);@override
+final NodeTable table;NodeData(this.specSlug, super.data);serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
+ serializer can be
+used to configure how individual values will be encoded. By default,
+DriftRuntimeOptions.defaultSerializer will be used. See
+ValueSerializer.defaults for details.
+ final String specSlug;STRICT.
+ LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ Uint8List. Example:
+ BigInt.
+ enum class T.
+ enum class T.
+ TextColumn get labels => text()();TextColumn get name => text()();TextColumn get propSpecs => text()();TextColumn get slug => text().unique()();NodeSpecCompanion.insert({
+ this.id = const Value.absent(),
+ required String name,
+ required String slug,
+ required String labels,
+ required String propSpecs,
+ this.rowid = const Value.absent(),
+}) : name = Value(name),
+ slug = Value(slug),
+ labels = Value(labels),
+ propSpecs = Value(propSpecs);NodeSpecCompanion copyWith(
+ {Value<String>? id,
+ Value<String>? name,
+ Value<String>? slug,
+ Value<String>? labels,
+ Value<String>? propSpecs,
+ Value<int>? rowid}) {
+ return NodeSpecCompanion(
+ id: id ?? this.id,
+ name: name ?? this.name,
+ slug: slug ?? this.slug,
+ labels: labels ?? this.labels,
+ propSpecs: propSpecs ?? this.propSpecs,
+ rowid: rowid ?? this.rowid,
+ );
+}static Insertable<NodeSpecData> custom({
+ Expression<String>? id,
+ Expression<String>? name,
+ Expression<String>? slug,
+ Expression<String>? labels,
+ Expression<String>? propSpecs,
+ Expression<int>? rowid,
+}) {
+ return RawValuesInsertable({
+ if (id != null) 'id': id,
+ if (name != null) 'name': name,
+ if (slug != null) 'slug': slug,
+ if (labels != null) 'labels': labels,
+ if (propSpecs != null) 'prop_specs': propSpecs,
+ if (rowid != null) 'rowid': rowid,
+ });
+}final Value<String> id;final Value<String> labels;final Value<String> name;final Value<String> propSpecs;final Value<int> rowid;final Value<String> slug;Converts this object into a map of column names to expressions to insert +or update.
+Note that the keys in the map are the raw column names, they're not +escaped.
+The nullToAbsent can be used on DataClasses to control whether null
+fields should be set to a null constant in sql or absent from the map.
+Other implementations ignore that nullToAbsent, it mainly exists for
+legacy reasons.
@override
+Map<String, Expression> toColumns(bool nullToAbsent) {
+ final map = <String, Expression>{};
+ if (id.present) {
+ map['id'] = Variable<String>(id.value);
+ }
+ if (name.present) {
+ map['name'] = Variable<String>(name.value);
+ }
+ if (slug.present) {
+ map['slug'] = Variable<String>(slug.value);
+ }
+ if (labels.present) {
+ map['labels'] = Variable<String>(labels.value);
+ }
+ if (propSpecs.present) {
+ map['prop_specs'] = Variable<String>(propSpecs.value);
+ }
+ if (rowid.present) {
+ map['rowid'] = Variable<int>(rowid.value);
+ }
+ return map;
+}A string representation of this object.
+Some classes have a default textual representation,
+often paired with a static parse function (like int.parse).
+These classes will provide the textual representation as
+their string representation.
Other classes have no meaningful textual representation
+that a program will care about.
+Such classes will typically override toString to provide
+useful information when inspecting the object,
+mainly for debugging or logging.
@override
+String toString() {
+ return (StringBuffer('NodeSpecCompanion(')
+ ..write('id: \$id, ')
+ ..write('name: \$name, ')
+ ..write('slug: \$slug, ')
+ ..write('labels: \$labels, ')
+ ..write('propSpecs: \$propSpecs, ')
+ ..write('rowid: \$rowid')
+ ..write(')'))
+ .toString();
+}NodeSpecDao(super.attachedDatabase);VALUES for an insert statement.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and SelectableUtils.watchSingle which return the item
+directly without wrapping it into a list.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and watchSingle which return the item directly without
+wrapping it into a list.
+ statement on the database.
+ updates parameter so that drift knows which tables are
+affected by your query. All select streams that depend on a table
+specified there will then update their data. For more accurate results,
+you can also set the updateKind parameter to UpdateKind.delete or
+UpdateKind.update. This is optional, but can improve the accuracy of
+query updates, especially when using triggers.
+ INSERT, UPDATE or DELETE statement returning rows.
+ fn after this executor is ready, or directly if it's
+already ready.
+ table by using InsertStatement.insert.
+ tables as updated.
+ updates to the stream query manager.
+ table that doesn't necessarily use all of
+table's columns.
+ action in a transaction, which means that all its queries and
+updates will be called atomically.
+ Future<int> get count {
+ final countExp = nodeSpec.id.count();
+ final q = selectOnly(nodeSpec)..addColumns([countExp]);
+
+ return q.map((row) => row.read(countExp)).getSingle().then((_) => _!);
+}Future<NodeSpecData> get(String id) {
+ final q = select(nodeSpec)..where((t) => t.id.equals(id));
+ return q.getSingle();
+}Future<List<NodeSpecData>> getAll() => select(nodeSpec).get();Future<NodeSpecData> getBySlug(String slug) {
+ final q = select(nodeSpec)..where((t) => t.slug.equals(slug));
+ return q.getSingle();
+}Future<bool> get isEmpty => count.then((value) => value == 0);\$NodeSpecTable get nodeSpec => attachedDatabase.nodeSpec;Future<NodeSpecData> put(Insertable<NodeSpecData> entity) =>
+ into(nodeSpec).insertReturning(entity, mode: InsertMode.insertOrReplace);Future<void> putAll(Iterable<Insertable<NodeSpecData>> entities) =>
+ batch((batch) => batch.insertAll(nodeSpec, entities,
+ mode: InsertMode.insertOrReplace));Future<NodeSpecData> putIfAbsent(Insertable<NodeSpecData> entity) =>
+ into(nodeSpec).insertReturning(entity, mode: InsertMode.insertOrIgnore);Stream<List<NodeSpecData>> watchAll() => select(nodeSpec).watch();factory NodeSpecData.fromJson(Map<String, dynamic> json,
+ {ValueSerializer? serializer}) {
+ serializer ??= driftRuntimeOptions.defaultSerializer;
+ return NodeSpecData(
+ id: serializer.fromJson<String>(json['id']),
+ name: serializer.fromJson<String>(json['name']),
+ slug: serializer.fromJson<String>(json['slug']),
+ labels: serializer.fromJson<String>(json['labels']),
+ propSpecs: serializer.fromJson<String>(json['propSpecs']),
+ );
+}json. The serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
+ serializer can be
+used to configure how individual values will be encoded. By default,
+DriftRuntimeOptions.defaultSerializer will be used. See
+ValueSerializer.defaults for details.
+ NodeSpecData copyWith(
+ {String? id,
+ String? name,
+ String? slug,
+ String? labels,
+ String? propSpecs}) =>
+ NodeSpecData(
+ id: id ?? this.id,
+ name: name ?? this.name,
+ slug: slug ?? this.slug,
+ labels: labels ?? this.labels,
+ propSpecs: propSpecs ?? this.propSpecs,
+ );The hash code for this object.
+A hash code is a single integer which represents the state of the object +that affects operator == comparisons.
+All objects have hash codes. +The default hash code implemented by Object +represents only the identity of the object, +the same way as the default operator == implementation only considers objects +equal if they are identical (see identityHashCode).
+If operator == is overridden to use the object state instead, +the hash code must also be changed to represent that state, +otherwise the object cannot be used in hash based data structures +like the default Set and Map implementations.
+Hash codes must be the same for objects that are equal to each other +according to operator ==. +The hash code of an object should only change if the object changes +in a way that affects equality. +There are no further requirements for the hash codes. +They need not be consistent between executions of the same program +and there are no distribution guarantees.
+Objects that are not equal are allowed to have the same hash code. +It is even technically allowed that all instances have the same hash code, +but if clashes happen too often, +it may reduce the efficiency of hash-based data structures +like HashSet or HashMap.
+If a subclass overrides hashCode, it should override the +operator == operator as well to maintain consistency.
+@override
+int get hashCode => Object.hash(id, name, slug, labels, propSpecs);final String id;final String labels;final String name;The equality operator.
+The default behavior for all Objects is to return true if and
+only if this object and other are the same object.
Override this method to specify a different equality relation on +a class. The overriding method must still be an equivalence relation. +That is, it must be:
+Total: It must return a boolean for all arguments. It should never throw.
+Reflexive: For all objects o, o == o must be true.
Symmetric: For all objects o1 and o2, o1 == o2 and o2 == o1 must
+either both be true, or both be false.
Transitive: For all objects o1, o2, and o3, if o1 == o2 and
+o2 == o3 are true, then o1 == o3 must be true.
The method should also be consistent over time, +so whether two objects are equal should only change +if at least one of the objects was modified.
+If a subclass overrides the equality operator, it should override +the hashCode method as well to maintain consistency.
+@override
+bool operator ==(Object other) =>
+ identical(this, other) ||
+ (other is NodeSpecData &&
+ other.id == this.id &&
+ other.name == this.name &&
+ other.slug == this.slug &&
+ other.labels == this.labels &&
+ other.propSpecs == this.propSpecs);final String propSpecs;final String slug;Converts this object into a map of column names to expressions to insert +or update.
+Note that the keys in the map are the raw column names, they're not +escaped.
+The nullToAbsent can be used on DataClasses to control whether null
+fields should be set to a null constant in sql or absent from the map.
+Other implementations ignore that nullToAbsent, it mainly exists for
+legacy reasons.
@override
+Map<String, Expression> toColumns(bool nullToAbsent) {
+ final map = <String, Expression>{};
+ map['id'] = Variable<String>(id);
+ map['name'] = Variable<String>(name);
+ map['slug'] = Variable<String>(slug);
+ map['labels'] = Variable<String>(labels);
+ map['prop_specs'] = Variable<String>(propSpecs);
+ return map;
+}NodeSpecCompanion toCompanion(bool nullToAbsent) {
+ return NodeSpecCompanion(
+ id: Value(id),
+ name: Value(name),
+ slug: Value(slug),
+ labels: Value(labels),
+ propSpecs: Value(propSpecs),
+ );
+}Converts this object into a representation that can be encoded with
+json. The serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
@override
+Map<String, dynamic> toJson({ValueSerializer? serializer}) {
+ serializer ??= driftRuntimeOptions.defaultSerializer;
+ return <String, dynamic>{
+ 'id': serializer.toJson<String>(id),
+ 'name': serializer.toJson<String>(name),
+ 'slug': serializer.toJson<String>(slug),
+ 'labels': serializer.toJson<String>(labels),
+ 'propSpecs': serializer.toJson<String>(propSpecs),
+ };
+}A string representation of this object.
+Some classes have a default textual representation,
+often paired with a static parse function (like int.parse).
+These classes will provide the textual representation as
+their string representation.
Other classes have no meaningful textual representation
+that a program will care about.
+Such classes will typically override toString to provide
+useful information when inspecting the object,
+mainly for debugging or logging.
@override
+String toString() {
+ return (StringBuffer('NodeSpecData(')
+ ..write('id: \$id, ')
+ ..write('name: \$name, ')
+ ..write('slug: \$slug, ')
+ ..write('labels: \$labels, ')
+ ..write('propSpecs: \$propSpecs')
+ ..write(')'))
+ .toString();
+}NodeTable(
+ this.specId,
+ this.specSlug,
+ super.\$columns, {
+ super.alias,
+ super.attachedDatabase,
+});Tbl and can thus just return their instance.
+ STRICT.
+ LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ Uint8List. Example:
+ alias
+when used in a query.
+ BigInt.
+ enum class T.
+ companion to the real model class, D.
+ enum class T.
+ The name of the table in the database. Unlike aliasedName, this can not +be aliased.
+@override
+String get actualTableName => specSlug;Creates an alias of this table or view that will write the name alias
+when used in a query.
@override
+NodeTable createAlias(String alias) => NodeTable(
+ specId,
+ specSlug,
+ \$columns,
+ alias: alias,
+ attachedDatabase: attachedDatabase,
+ );Maps the given row returned by the database into the fitting data class.
+@override
+FutureOr<NodeData> map(Map<String, dynamic> data, {String? tablePrefix}) =>
+ NodeData(specSlug, data);final String specId;final String specSlug;LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ STRICT.
+ Uint8List. Example:
+ BigInt.
+ enum class T.
+ enum class T.
+ TextColumn get id => text().clientDefault(
+ () => Slugid.nice().toString(), // Compressed UUIDv4
+ )();Override this to specify custom primary keys:
+class IngredientInRecipes extends Table {
+ @override
+ Set<Column> get primaryKey => {recipe, ingredient};
+
+ IntColumn get recipe => integer()();
+ IntColumn get ingredient => integer()();
+
+ IntColumn get amountInGrams => integer().named('amount')();
+}
+The getter must return a set literal using the => syntax so that the
+drift generator can understand the code.
+Also, please note that it's an error to have an
+BuildIntColumn.autoIncrement column and a custom primary key.
+As an auto-incremented IntColumn is recognized by drift to be the
+primary key, doing so will result in an exception thrown at runtime.
@override
+Set<Column> get primaryKey => {id};UngraphDatabase description
+UngraphDatabase([QueryExecutor? qe]) : super(qe ?? connect().executor);UngraphDatabase description
+DatabaseSchemaEntity that are specified in this database.
+ VALUES for an insert statement.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and SelectableUtils.watchSingle which return the item
+directly without wrapping it into a list.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and watchSingle which return the item directly without
+wrapping it into a list.
+ statement on the database.
+ updates parameter so that drift knows which tables are
+affected by your query. All select streams that depend on a table
+specified there will then update their data. For more accurate results,
+you can also set the updateKind parameter to UpdateKind.delete or
+UpdateKind.update. This is optional, but can improve the accuracy of
+query updates, especially when using triggers.
+ INSERT, UPDATE or DELETE statement returning rows.
+ fn after this executor is ready, or directly if it's
+already ready.
+ table by using InsertStatement.insert.
+ tables as updated.
+ updates to the stream query manager.
+ table that doesn't necessarily use all of
+table's columns.
+ action in a transaction, which means that all its queries and
+updates will be called atomically.
+ A list of all DatabaseSchemaEntity that are specified in this database.
This contains allTables, but also advanced entities like triggers.
+@override
+List<DatabaseSchemaEntity> get allSchemaEntities =>
+ [unpackSpec, unpackState, nodeSpec, edgeSpec];A list of tables specified in this database.
+@override
+Iterable<TableInfo<Table, Object?>> get allTables =>
+ allSchemaEntities.whereType<TableInfo<Table, Object?>>();DynamicDatabase get dynamic => dynamicDatabase;late final DynamicDatabase dynamicDatabase =
+ DynamicDatabase(this as UngraphDatabase);late final \$EdgeSpecTable edgeSpec = \$EdgeSpecTable(this);late final EdgeSpecDao edgeSpecDao = EdgeSpecDao(this as UngraphDatabase);Defines the migration strategy that will determine how to deal with an +increasing schemaVersion. The default value only supports creating the +database by creating all tables known in this database. When you have +changes in your schema, you'll need a custom migration strategy to create +the new tables or change the columns.
+@override
+MigrationStrategy get migration => MigrationStrategy(
+ onCreate: (Migrator m) async {
+ await m.createAll();
+ },
+ onUpgrade: (m, from, to) async {
+ // disable foreign_keys before migrations
+ await customStatement('PRAGMA foreign_keys = OFF');
+ },
+ beforeOpen: (details) async {
+ // foreign key references aren't enabled by default
+ await customStatement('PRAGMA foreign_keys = ON');
+ // collectionDao.
+ },
+ );late final \$NodeSpecTable nodeSpec = \$NodeSpecTable(this);late final NodeSpecDao nodeSpecDao = NodeSpecDao(this as UngraphDatabase);Specify the schema version of your database. Whenever you change or add +tables, you should bump this field and provide a migration strategy.
+@override
+int get schemaVersion => 1;late final \$UnpackSpecTable unpackSpec = \$UnpackSpecTable(this);late final UnpackSpecDao unpackSpecDao =
+ UnpackSpecDao(this as UngraphDatabase);late final \$UnpackStateTable unpackState = \$UnpackStateTable(this);late final UnpackStateDao unpackStateDao =
+ UnpackStateDao(this as UngraphDatabase);STRICT.
+ LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ Uint8List. Example:
+ BigInt.
+ enum class T.
+ enum class T.
+ TextColumn get fileSpec => text()();TextColumn get modules => text()();TextColumn get name => text()();TextColumn get retrieveSpec => text()();TextColumn get slug => text().unique()();UnpackSpecCompanion.insert({
+ this.id = const Value.absent(),
+ required String slug,
+ required String name,
+ required String fileSpec,
+ required String retrieveSpec,
+ required String modules,
+ this.rowid = const Value.absent(),
+}) : slug = Value(slug),
+ name = Value(name),
+ fileSpec = Value(fileSpec),
+ retrieveSpec = Value(retrieveSpec),
+ modules = Value(modules);UnpackSpecCompanion copyWith(
+ {Value<String>? id,
+ Value<String>? slug,
+ Value<String>? name,
+ Value<String>? fileSpec,
+ Value<String>? retrieveSpec,
+ Value<String>? modules,
+ Value<int>? rowid}) {
+ return UnpackSpecCompanion(
+ id: id ?? this.id,
+ slug: slug ?? this.slug,
+ name: name ?? this.name,
+ fileSpec: fileSpec ?? this.fileSpec,
+ retrieveSpec: retrieveSpec ?? this.retrieveSpec,
+ modules: modules ?? this.modules,
+ rowid: rowid ?? this.rowid,
+ );
+}static Insertable<UnpackSpecData> custom({
+ Expression<String>? id,
+ Expression<String>? slug,
+ Expression<String>? name,
+ Expression<String>? fileSpec,
+ Expression<String>? retrieveSpec,
+ Expression<String>? modules,
+ Expression<int>? rowid,
+}) {
+ return RawValuesInsertable({
+ if (id != null) 'id': id,
+ if (slug != null) 'slug': slug,
+ if (name != null) 'name': name,
+ if (fileSpec != null) 'file_spec': fileSpec,
+ if (retrieveSpec != null) 'retrieve_spec': retrieveSpec,
+ if (modules != null) 'modules': modules,
+ if (rowid != null) 'rowid': rowid,
+ });
+}final Value<String> fileSpec;final Value<String> id;final Value<String> modules;final Value<String> name;final Value<String> retrieveSpec;final Value<int> rowid;final Value<String> slug;Converts this object into a map of column names to expressions to insert +or update.
+Note that the keys in the map are the raw column names, they're not +escaped.
+The nullToAbsent can be used on DataClasses to control whether null
+fields should be set to a null constant in sql or absent from the map.
+Other implementations ignore that nullToAbsent, it mainly exists for
+legacy reasons.
@override
+Map<String, Expression> toColumns(bool nullToAbsent) {
+ final map = <String, Expression>{};
+ if (id.present) {
+ map['id'] = Variable<String>(id.value);
+ }
+ if (slug.present) {
+ map['slug'] = Variable<String>(slug.value);
+ }
+ if (name.present) {
+ map['name'] = Variable<String>(name.value);
+ }
+ if (fileSpec.present) {
+ map['file_spec'] = Variable<String>(fileSpec.value);
+ }
+ if (retrieveSpec.present) {
+ map['retrieve_spec'] = Variable<String>(retrieveSpec.value);
+ }
+ if (modules.present) {
+ map['modules'] = Variable<String>(modules.value);
+ }
+ if (rowid.present) {
+ map['rowid'] = Variable<int>(rowid.value);
+ }
+ return map;
+}A string representation of this object.
+Some classes have a default textual representation,
+often paired with a static parse function (like int.parse).
+These classes will provide the textual representation as
+their string representation.
Other classes have no meaningful textual representation
+that a program will care about.
+Such classes will typically override toString to provide
+useful information when inspecting the object,
+mainly for debugging or logging.
@override
+String toString() {
+ return (StringBuffer('UnpackSpecCompanion(')
+ ..write('id: \$id, ')
+ ..write('slug: \$slug, ')
+ ..write('name: \$name, ')
+ ..write('fileSpec: \$fileSpec, ')
+ ..write('retrieveSpec: \$retrieveSpec, ')
+ ..write('modules: \$modules, ')
+ ..write('rowid: \$rowid')
+ ..write(')'))
+ .toString();
+}UnpackSpecDao(super.attachedDatabase);VALUES for an insert statement.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and SelectableUtils.watchSingle which return the item
+directly without wrapping it into a list.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and watchSingle which return the item directly without
+wrapping it into a list.
+ statement on the database.
+ updates parameter so that drift knows which tables are
+affected by your query. All select streams that depend on a table
+specified there will then update their data. For more accurate results,
+you can also set the updateKind parameter to UpdateKind.delete or
+UpdateKind.update. This is optional, but can improve the accuracy of
+query updates, especially when using triggers.
+ INSERT, UPDATE or DELETE statement returning rows.
+ fn after this executor is ready, or directly if it's
+already ready.
+ table by using InsertStatement.insert.
+ tables as updated.
+ updates to the stream query manager.
+ table that doesn't necessarily use all of
+table's columns.
+ action in a transaction, which means that all its queries and
+updates will be called atomically.
+ Future<int> get count {
+ final countExp = unpackSpec.id.count();
+ final q = selectOnly(unpackSpec)..addColumns([countExp]);
+
+ return q.map((row) => row.read(countExp)).getSingle().then((_) => _!);
+}Future<UnpackSpecData> get(String id) {
+ final q = select(unpackSpec)..where((t) => t.id.equals(id));
+ return q.getSingle();
+}Future<List<UnpackSpecData>> getAll() => select(unpackSpec).get();Future<bool> get isEmpty => count.then((value) => value == 0);Future<UnpackSpecData> put(Insertable<UnpackSpecData> entity) =>
+ into(unpackSpec)
+ .insertReturning(entity, mode: InsertMode.insertOrReplace);Future<void> putAll(Iterable<Insertable<UnpackSpecData>> entities) =>
+ batch((batch) => batch.insertAll(unpackSpec, entities,
+ mode: InsertMode.insertOrReplace));\$UnpackSpecTable get unpackSpec => attachedDatabase.unpackSpec;Stream<List<UnpackSpecData>> watchAll() => select(unpackSpec).watch();const UnpackSpecData(
+ {required this.id,
+ required this.slug,
+ required this.name,
+ required this.fileSpec,
+ required this.retrieveSpec,
+ required this.modules});json. The serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
+ serializer can be
+used to configure how individual values will be encoded. By default,
+DriftRuntimeOptions.defaultSerializer will be used. See
+ValueSerializer.defaults for details.
+ UnpackSpecData copyWith(
+ {String? id,
+ String? slug,
+ String? name,
+ String? fileSpec,
+ String? retrieveSpec,
+ String? modules}) =>
+ UnpackSpecData(
+ id: id ?? this.id,
+ slug: slug ?? this.slug,
+ name: name ?? this.name,
+ fileSpec: fileSpec ?? this.fileSpec,
+ retrieveSpec: retrieveSpec ?? this.retrieveSpec,
+ modules: modules ?? this.modules,
+ );final String fileSpec;The hash code for this object.
+A hash code is a single integer which represents the state of the object +that affects operator == comparisons.
+All objects have hash codes. +The default hash code implemented by Object +represents only the identity of the object, +the same way as the default operator == implementation only considers objects +equal if they are identical (see identityHashCode).
+If operator == is overridden to use the object state instead, +the hash code must also be changed to represent that state, +otherwise the object cannot be used in hash based data structures +like the default Set and Map implementations.
+Hash codes must be the same for objects that are equal to each other +according to operator ==. +The hash code of an object should only change if the object changes +in a way that affects equality. +There are no further requirements for the hash codes. +They need not be consistent between executions of the same program +and there are no distribution guarantees.
+Objects that are not equal are allowed to have the same hash code. +It is even technically allowed that all instances have the same hash code, +but if clashes happen too often, +it may reduce the efficiency of hash-based data structures +like HashSet or HashMap.
+If a subclass overrides hashCode, it should override the +operator == operator as well to maintain consistency.
+@override
+int get hashCode =>
+ Object.hash(id, slug, name, fileSpec, retrieveSpec, modules);final String id;final String modules;final String name;The equality operator.
+The default behavior for all Objects is to return true if and
+only if this object and other are the same object.
Override this method to specify a different equality relation on +a class. The overriding method must still be an equivalence relation. +That is, it must be:
+Total: It must return a boolean for all arguments. It should never throw.
+Reflexive: For all objects o, o == o must be true.
Symmetric: For all objects o1 and o2, o1 == o2 and o2 == o1 must
+either both be true, or both be false.
Transitive: For all objects o1, o2, and o3, if o1 == o2 and
+o2 == o3 are true, then o1 == o3 must be true.
The method should also be consistent over time, +so whether two objects are equal should only change +if at least one of the objects was modified.
+If a subclass overrides the equality operator, it should override +the hashCode method as well to maintain consistency.
+@override
+bool operator ==(Object other) =>
+ identical(this, other) ||
+ (other is UnpackSpecData &&
+ other.id == this.id &&
+ other.slug == this.slug &&
+ other.name == this.name &&
+ other.fileSpec == this.fileSpec &&
+ other.retrieveSpec == this.retrieveSpec &&
+ other.modules == this.modules);final String retrieveSpec;final String slug;Converts this object into a map of column names to expressions to insert +or update.
+Note that the keys in the map are the raw column names, they're not +escaped.
+The nullToAbsent can be used on DataClasses to control whether null
+fields should be set to a null constant in sql or absent from the map.
+Other implementations ignore that nullToAbsent, it mainly exists for
+legacy reasons.
@override
+Map<String, Expression> toColumns(bool nullToAbsent) {
+ final map = <String, Expression>{};
+ map['id'] = Variable<String>(id);
+ map['slug'] = Variable<String>(slug);
+ map['name'] = Variable<String>(name);
+ map['file_spec'] = Variable<String>(fileSpec);
+ map['retrieve_spec'] = Variable<String>(retrieveSpec);
+ map['modules'] = Variable<String>(modules);
+ return map;
+}UnpackSpecCompanion toCompanion(bool nullToAbsent) {
+ return UnpackSpecCompanion(
+ id: Value(id),
+ slug: Value(slug),
+ name: Value(name),
+ fileSpec: Value(fileSpec),
+ retrieveSpec: Value(retrieveSpec),
+ modules: Value(modules),
+ );
+}Converts this object into a representation that can be encoded with
+json. The serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
@override
+Map<String, dynamic> toJson({ValueSerializer? serializer}) {
+ serializer ??= driftRuntimeOptions.defaultSerializer;
+ return <String, dynamic>{
+ 'id': serializer.toJson<String>(id),
+ 'slug': serializer.toJson<String>(slug),
+ 'name': serializer.toJson<String>(name),
+ 'fileSpec': serializer.toJson<String>(fileSpec),
+ 'retrieveSpec': serializer.toJson<String>(retrieveSpec),
+ 'modules': serializer.toJson<String>(modules),
+ };
+}A string representation of this object.
+Some classes have a default textual representation,
+often paired with a static parse function (like int.parse).
+These classes will provide the textual representation as
+their string representation.
Other classes have no meaningful textual representation
+that a program will care about.
+Such classes will typically override toString to provide
+useful information when inspecting the object,
+mainly for debugging or logging.
@override
+String toString() {
+ return (StringBuffer('UnpackSpecData(')
+ ..write('id: \$id, ')
+ ..write('slug: \$slug, ')
+ ..write('name: \$name, ')
+ ..write('fileSpec: \$fileSpec, ')
+ ..write('retrieveSpec: \$retrieveSpec, ')
+ ..write('modules: \$modules')
+ ..write(')'))
+ .toString();
+}STRICT.
+ LocalSettings will be called local_settings by
+default.
+You can change that behavior by overriding this method to use a custom
+name. Please note that you must directly return a string literal by using
+a getter. For instance @override String get tableName => 'my_table'; is
+valid, whereas @override final String tableName = 'my_table'; or
+@override String get tableName => createMyTableName(); is not.
+ WITHOUT ROWID clause in the CREATE TABLE
+statement. This is intended to be used by generated code only.
+ Uint8List. Example:
+ BigInt.
+ enum class T.
+ enum class T.
+ TextColumn get filePath => text().nullable()();TextColumn get selectedModules => text().nullable()();TextColumn get specId => text().references(UnpackSpec, #id)();TextColumn get step => text()();UnpackStateCompanion.insert({
+ this.id = const Value.absent(),
+ required String specId,
+ required String step,
+ this.selectedModules = const Value.absent(),
+ this.filePath = const Value.absent(),
+ this.rowid = const Value.absent(),
+}) : specId = Value(specId),
+ step = Value(step);UnpackStateCompanion copyWith(
+ {Value<String>? id,
+ Value<String>? specId,
+ Value<String>? step,
+ Value<String?>? selectedModules,
+ Value<String?>? filePath,
+ Value<int>? rowid}) {
+ return UnpackStateCompanion(
+ id: id ?? this.id,
+ specId: specId ?? this.specId,
+ step: step ?? this.step,
+ selectedModules: selectedModules ?? this.selectedModules,
+ filePath: filePath ?? this.filePath,
+ rowid: rowid ?? this.rowid,
+ );
+}static Insertable<UnpackStateData> custom({
+ Expression<String>? id,
+ Expression<String>? specId,
+ Expression<String>? step,
+ Expression<String>? selectedModules,
+ Expression<String>? filePath,
+ Expression<int>? rowid,
+}) {
+ return RawValuesInsertable({
+ if (id != null) 'id': id,
+ if (specId != null) 'spec_id': specId,
+ if (step != null) 'step': step,
+ if (selectedModules != null) 'selected_modules': selectedModules,
+ if (filePath != null) 'file_path': filePath,
+ if (rowid != null) 'rowid': rowid,
+ });
+}final Value<String?> filePath;final Value<String> id;final Value<int> rowid;final Value<String?> selectedModules;final Value<String> specId;final Value<String> step;Converts this object into a map of column names to expressions to insert +or update.
+Note that the keys in the map are the raw column names, they're not +escaped.
+The nullToAbsent can be used on DataClasses to control whether null
+fields should be set to a null constant in sql or absent from the map.
+Other implementations ignore that nullToAbsent, it mainly exists for
+legacy reasons.
@override
+Map<String, Expression> toColumns(bool nullToAbsent) {
+ final map = <String, Expression>{};
+ if (id.present) {
+ map['id'] = Variable<String>(id.value);
+ }
+ if (specId.present) {
+ map['spec_id'] = Variable<String>(specId.value);
+ }
+ if (step.present) {
+ map['step'] = Variable<String>(step.value);
+ }
+ if (selectedModules.present) {
+ map['selected_modules'] = Variable<String>(selectedModules.value);
+ }
+ if (filePath.present) {
+ map['file_path'] = Variable<String>(filePath.value);
+ }
+ if (rowid.present) {
+ map['rowid'] = Variable<int>(rowid.value);
+ }
+ return map;
+}A string representation of this object.
+Some classes have a default textual representation,
+often paired with a static parse function (like int.parse).
+These classes will provide the textual representation as
+their string representation.
Other classes have no meaningful textual representation
+that a program will care about.
+Such classes will typically override toString to provide
+useful information when inspecting the object,
+mainly for debugging or logging.
@override
+String toString() {
+ return (StringBuffer('UnpackStateCompanion(')
+ ..write('id: \$id, ')
+ ..write('specId: \$specId, ')
+ ..write('step: \$step, ')
+ ..write('selectedModules: \$selectedModules, ')
+ ..write('filePath: \$filePath, ')
+ ..write('rowid: \$rowid')
+ ..write(')'))
+ .toString();
+}UnpackStateDao(super.attachedDatabase);VALUES for an insert statement.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and SelectableUtils.watchSingle which return the item
+directly without wrapping it into a list.
+ query. To run the
+query once, use Selectable.get. For an auto-updating streams, set the
+set of tables the ready readsFrom and use Selectable.watch. If you
+know the query will never emit more than one row, you can also use
+getSingle and watchSingle which return the item directly without
+wrapping it into a list.
+ statement on the database.
+ updates parameter so that drift knows which tables are
+affected by your query. All select streams that depend on a table
+specified there will then update their data. For more accurate results,
+you can also set the updateKind parameter to UpdateKind.delete or
+UpdateKind.update. This is optional, but can improve the accuracy of
+query updates, especially when using triggers.
+ INSERT, UPDATE or DELETE statement returning rows.
+ fn after this executor is ready, or directly if it's
+already ready.
+ table by using InsertStatement.insert.
+ tables as updated.
+ updates to the stream query manager.
+ table that doesn't necessarily use all of
+table's columns.
+ action in a transaction, which means that all its queries and
+updates will be called atomically.
+ Future<int> get count {
+ final countExp = unpackState.id.count();
+ final q = selectOnly(unpackState)..addColumns([countExp]);
+
+ return q.map((row) => row.read(countExp)).getSingle().then((_) => _!);
+}Future<UnpackStateData> get(String id) =>
+ (select(unpackState)..where((t) => t.id.equals(id))).getSingle();Future<List<UnpackStateData>> getAll() => select(unpackState).get();Future<bool> get isEmpty => count.then((value) => value == 0);Future<UnpackStateData> put(Insertable<UnpackStateData> entity) =>
+ into(unpackState)
+ .insertReturning(entity, mode: InsertMode.insertOrReplace);\$UnpackSpecTable get unpackSpec => attachedDatabase.unpackSpec;\$UnpackStateTable get unpackState => attachedDatabase.unpackState;Stream<List<UnpackStateData>> watchAll() => select(unpackState).watch();const UnpackStateData(
+ {required this.id,
+ required this.specId,
+ required this.step,
+ this.selectedModules,
+ this.filePath});json. The serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
+ serializer can be
+used to configure how individual values will be encoded. By default,
+DriftRuntimeOptions.defaultSerializer will be used. See
+ValueSerializer.defaults for details.
+ UnpackStateData copyWith(
+ {String? id,
+ String? specId,
+ String? step,
+ Value<String?> selectedModules = const Value.absent(),
+ Value<String?> filePath = const Value.absent()}) =>
+ UnpackStateData(
+ id: id ?? this.id,
+ specId: specId ?? this.specId,
+ step: step ?? this.step,
+ selectedModules: selectedModules.present
+ ? selectedModules.value
+ : this.selectedModules,
+ filePath: filePath.present ? filePath.value : this.filePath,
+ );final String? filePath;The hash code for this object.
+A hash code is a single integer which represents the state of the object +that affects operator == comparisons.
+All objects have hash codes. +The default hash code implemented by Object +represents only the identity of the object, +the same way as the default operator == implementation only considers objects +equal if they are identical (see identityHashCode).
+If operator == is overridden to use the object state instead, +the hash code must also be changed to represent that state, +otherwise the object cannot be used in hash based data structures +like the default Set and Map implementations.
+Hash codes must be the same for objects that are equal to each other +according to operator ==. +The hash code of an object should only change if the object changes +in a way that affects equality. +There are no further requirements for the hash codes. +They need not be consistent between executions of the same program +and there are no distribution guarantees.
+Objects that are not equal are allowed to have the same hash code. +It is even technically allowed that all instances have the same hash code, +but if clashes happen too often, +it may reduce the efficiency of hash-based data structures +like HashSet or HashMap.
+If a subclass overrides hashCode, it should override the +operator == operator as well to maintain consistency.
+@override
+int get hashCode => Object.hash(id, specId, step, selectedModules, filePath);final String id;The equality operator.
+The default behavior for all Objects is to return true if and
+only if this object and other are the same object.
Override this method to specify a different equality relation on +a class. The overriding method must still be an equivalence relation. +That is, it must be:
+Total: It must return a boolean for all arguments. It should never throw.
+Reflexive: For all objects o, o == o must be true.
Symmetric: For all objects o1 and o2, o1 == o2 and o2 == o1 must
+either both be true, or both be false.
Transitive: For all objects o1, o2, and o3, if o1 == o2 and
+o2 == o3 are true, then o1 == o3 must be true.
The method should also be consistent over time, +so whether two objects are equal should only change +if at least one of the objects was modified.
+If a subclass overrides the equality operator, it should override +the hashCode method as well to maintain consistency.
+@override
+bool operator ==(Object other) =>
+ identical(this, other) ||
+ (other is UnpackStateData &&
+ other.id == this.id &&
+ other.specId == this.specId &&
+ other.step == this.step &&
+ other.selectedModules == this.selectedModules &&
+ other.filePath == this.filePath);final String? selectedModules;final String specId;final String step;Converts this object into a map of column names to expressions to insert +or update.
+Note that the keys in the map are the raw column names, they're not +escaped.
+The nullToAbsent can be used on DataClasses to control whether null
+fields should be set to a null constant in sql or absent from the map.
+Other implementations ignore that nullToAbsent, it mainly exists for
+legacy reasons.
@override
+Map<String, Expression> toColumns(bool nullToAbsent) {
+ final map = <String, Expression>{};
+ map['id'] = Variable<String>(id);
+ map['spec_id'] = Variable<String>(specId);
+ map['step'] = Variable<String>(step);
+ if (!nullToAbsent || selectedModules != null) {
+ map['selected_modules'] = Variable<String>(selectedModules);
+ }
+ if (!nullToAbsent || filePath != null) {
+ map['file_path'] = Variable<String>(filePath);
+ }
+ return map;
+}UnpackStateCompanion toCompanion(bool nullToAbsent) {
+ return UnpackStateCompanion(
+ id: Value(id),
+ specId: Value(specId),
+ step: Value(step),
+ selectedModules: selectedModules == null && nullToAbsent
+ ? const Value.absent()
+ : Value(selectedModules),
+ filePath: filePath == null && nullToAbsent
+ ? const Value.absent()
+ : Value(filePath),
+ );
+}Converts this object into a representation that can be encoded with
+json. The serializer can be used to configure how individual values
+will be encoded. By default, DriftRuntimeOptions.defaultSerializer will
+be used. See ValueSerializer.defaults for details.
@override
+Map<String, dynamic> toJson({ValueSerializer? serializer}) {
+ serializer ??= driftRuntimeOptions.defaultSerializer;
+ return <String, dynamic>{
+ 'id': serializer.toJson<String>(id),
+ 'specId': serializer.toJson<String>(specId),
+ 'step': serializer.toJson<String>(step),
+ 'selectedModules': serializer.toJson<String?>(selectedModules),
+ 'filePath': serializer.toJson<String?>(filePath),
+ };
+}A string representation of this object.
+Some classes have a default textual representation,
+often paired with a static parse function (like int.parse).
+These classes will provide the textual representation as
+their string representation.
Other classes have no meaningful textual representation
+that a program will care about.
+Such classes will typically override toString to provide
+useful information when inspecting the object,
+mainly for debugging or logging.
@override
+String toString() {
+ return (StringBuffer('UnpackStateData(')
+ ..write('id: \$id, ')
+ ..write('specId: \$specId, ')
+ ..write('step: \$step, ')
+ ..write('selectedModules: \$selectedModules, ')
+ ..write('filePath: \$filePath')
+ ..write(')'))
+ .toString();
+}DatabaseConnection connect() {
+ throw UnsupportedError(
+ 'No suitable database implementation was found on this platform.');
+}== padding.
+T to indicate presence or absence
+explicitly.
+static Edge entityToModel(EdgeData data) => Edge(
+ specSlug: data.specSlug,
+ properties: data.data,
+ );static EdgeData modelToEntity(Edge model) =>
+ EdgeData(model.specSlug, model.properties);const EdgeRepository(this.spec, this._dao);Future<List<Edge>> getAll() =>
+ _dao.getAll().then((list) => list.map(EdgeMapper.entityToModel).toList());final EdgeSpec spec;static EdgeSpec entityToModel(EdgeSpecData data) => EdgeSpec(
+ id: data.id,
+ slugged: data.slug,
+ name: data.name,
+ type: data.type,
+ sourceNodeSpecId: data.sourceNodeSpecId,
+ targetNodeSpecId: data.targetNodeSpecId,
+ propSpecs: (jsonDecode(data.propSpecs) as List)
+ .map((_) => PropSpec.fromJson(_))
+ .toList(),
+ );static EdgeDao modelToDao(EdgeSpec model, [UngraphDatabase? db]) =>
+ EdgeDao(modelToTable(model), db);static EdgeSpecCompanion modelToEntity(EdgeSpec model) =>
+ EdgeSpecCompanion.insert(
+ id: model.id != null ? Value(model.id!) : const Value.absent(),
+ slug: model.slug,
+ name: model.name,
+ type: model.type,
+ sourceNodeSpecId: model.sourceNodeSpecId,
+ targetNodeSpecId: model.targetNodeSpecId,
+ propSpecs: jsonEncode(model.propSpecs),
+ );static EdgeTable modelToTable(EdgeSpec model) => EdgeTable(
+ model.id!,
+ model.slug,
+ model.propSpecs.map(PropSpecMapper.modelToColumn).toList(),
+ );An interface for UngraphRepository
+static Node entityToModel(NodeData data) => Node(
+ specSlug: data.specSlug,
+ properties: data.data,
+ );static NodeData modelToEntity(Node model) =>
+ NodeData(model.specSlug, model.properties);const NodeRepository(this.spec, this._dao);Future<List<Node>> getAll() =>
+ _dao.getAll().then((list) => list.map(NodeMapper.entityToModel).toList());Future<Node> put(Node node) =>
+ _dao.put(NodeMapper.modelToEntity(node)).then(NodeMapper.entityToModel);final NodeSpec spec;static NodeSpec entityToModel(NodeSpecData data) => NodeSpec(
+ id: data.id,
+ slugged: data.slug,
+ name: data.name,
+ propSpecs: (jsonDecode(data.propSpecs) as List)
+ .map((_) => PropSpec.fromJson(_))
+ .toList(),
+ );static NodeDao modelToDao(NodeSpec model, [UngraphDatabase? db]) =>
+ NodeDao(modelToTable(model), db);static NodeSpecCompanion modelToEntity(NodeSpec model) =>
+ NodeSpecCompanion.insert(
+ id: model.id != null ? Value(model.id!) : const Value.absent(),
+ slug: model.slug,
+ name: model.name,
+ labels: jsonEncode(model.labels),
+ propSpecs: jsonEncode(model.propSpecs),
+ );static NodeTable modelToTable(NodeSpec model) => NodeTable(
+ model.id!,
+ model.slug,
+ model.propSpecs.map(PropSpecMapper.modelToColumn).toList(),
+ );static DynamicColumn modelToColumn(PropSpec model) =>
+ DynamicColumn.fromString(
+ 'id',
+ 'test_table',
+ false,
+ type: model.type,
+ );const UngraphRepository(this._db);Future<Iterable<String>> getEdgeOfNode(String slugs) =>
+ _db.edgeSpecDao.getAllByNode(slugs);Future<EdgeRepository> initEdge(String specSlug) async {
+ final spec = EdgeSpecMapper.entityToModel(
+ await _db.edgeSpecDao.getBySlug(specSlug),
+ );
+
+ final dao = EdgeSpecMapper.modelToDao(spec, _db);
+ await dao.createTable();
+
+ return EdgeRepository(spec, dao);
+}Future<NodeRepository> initNode(String specSlug) async {
+ final spec = NodeSpecMapper.entityToModel(
+ await _db.nodeSpecDao.getBySlug(specSlug),
+ );
+
+ final dao = NodeSpecMapper.modelToDao(spec, _db);
+ await dao.createTable();
+
+ return NodeRepository(spec, dao);
+}Future<EdgeSpecData> registerEdge(EdgeSpec spec) =>
+ _db.edgeSpecDao.put(EdgeSpecMapper.modelToEntity(spec));Future<NodeSpecData> registerNode(NodeSpec spec) =>
+ _db.nodeSpecDao.put(NodeSpecMapper.modelToEntity(spec));Stream<List<String>> watchTables() => _db.dynamic.queryTables().watch();typedef Accumulator = void Function(String key, dynamic value);const ExtractJson(super.spec);@override
+FutureOr<Map<String, dynamic>> extract(Iterable<int> bytes) =>
+ jsonDecode(String.fromCharCodes(bytes));const IExtract(this.spec);FutureOr<Map<String, O>> extract(Iterable<int> bytes);static IExtract extractor(ExtractSpec spec) => spec.map(
+ json: (_) => ExtractJson(spec),
+ );final ExtractSpec spec;const IFile(this.moduleSpec);static IFile filer(
+ ModuleSpec moduleSpec,
+ FileSpec fileSpec,
+) =>
+ fileSpec.map(
+ zip: (_) => ZipFile(moduleSpec),
+ );final ModuleSpec moduleSpec;FutureOr<Map<String, Iterable<int>>> prepare(XFile file);const ILoad(this.spec);FutureOr<bool> load(Map<String, I> data);static ILoad loader(LoadSpec spec) => spec.map(
+ ungraph: (_) => LoadUngraph(_),
+ );final LoadSpec spec;const IRetrieve();static IRetrieve factory(RetrieveSpec spec) => spec.map(
+ localFile: (_) => const RetrieveLocalFile(),
+ );FutureOr<XFile?> retrieve();const ITransform(this.spec);final TransformSpec spec;static ITransform tranformer(TransformSpec spec) => spec.map(
+ json: (_) => TransformJson(_),
+ );FutureOr<Map<String, O>> transform(Map<String, I> data);const IUnpack(this.spec);FutureOr<void> configure(Iterable<ModuleSpec> selectedModules);UnpackState get currentState;UnpackStep get currentStep;FutureOr<void> dispose();String get id;FutureOr<void> process();Stream<UnpackProgress> get progress;FutureOr<void> retrieve();final UnpackSpec spec;Stream<UnpackState> get states;factory JsonNormalizer(Iterable<JsonSchema> schema) => JsonNormalizer._({
+ for (final entity in schema) entity.name: entity,
+ });void accumulate(
+ String entity,
+ Map<String, dynamic> json,
+ AccumulatorCallback accumulator,
+) =>
+ t.normalize(json, _find(entity), accumulator, _find);Map<String, Iterable> normalize(String entity, Map<String, dynamic> json) =>
+ normalizeWith(_find(entity), json);Map<String, Iterable> normalizeUnique(
+ JsonSchema entity,
+ Map<String, dynamic> json,
+) {
+ final result = <String, Set>{};
+ void accumulator(String name, dynamic key, dynamic entity) {
+ result[name] ??= {};
+ result[name]!.add(entity is Map ? BuiltMap.of(entity) : entity);
+ }
+
+ t.normalize(json, entity, accumulator, _find);
+
+ return result;
+}Map<String, Iterable> normalizeWith(
+ JsonSchema entity,
+ Map<String, dynamic> json,
+) {
+ final result = <String, List>{};
+ void accumulator(String name, dynamic key, dynamic entity) {
+ result[name] ??= [];
+ result[name]!.add(entity);
+ }
+
+ t.normalize(json, entity, accumulator, _find);
+
+ return result;
+}const LoadUngraph(super.spec);@override
+FutureOr<bool> load(Map<String, dynamic> data) {
+ return true;
+}const factory ModuleComplete() = _\$ModuleComplete;const factory ModuleError() = _\$ModuleError;const factory ModuleExtract() = _\$ModuleExtract;const factory ModuleFile() = _\$ModuleFile;const factory ModuleInitial() = _\$ModuleInitial;const factory ModuleLoad() = _\$ModuleLoad;const factory ModuleState.file() = ModuleFile;@optionalTypeArgs
+TResult map<TResult extends Object?>({
+ required TResult Function(ModuleInitial value) initial,
+ required TResult Function(ModuleFile value) file,
+ required TResult Function(ModuleExtract value) extract,
+ required TResult Function(ModuleTransform value) transform,
+ required TResult Function(ModuleLoad value) load,
+ required TResult Function(ModuleComplete value) complete,
+ required TResult Function(ModuleError value) error,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? mapOrNull<TResult extends Object?>({
+ TResult? Function(ModuleInitial value)? initial,
+ TResult? Function(ModuleFile value)? file,
+ TResult? Function(ModuleExtract value)? extract,
+ TResult? Function(ModuleTransform value)? transform,
+ TResult? Function(ModuleLoad value)? load,
+ TResult? Function(ModuleComplete value)? complete,
+ TResult? Function(ModuleError value)? error,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeMap<TResult extends Object?>({
+ TResult Function(ModuleInitial value)? initial,
+ TResult Function(ModuleFile value)? file,
+ TResult Function(ModuleExtract value)? extract,
+ TResult Function(ModuleTransform value)? transform,
+ TResult Function(ModuleLoad value)? load,
+ TResult Function(ModuleComplete value)? complete,
+ TResult Function(ModuleError value)? error,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeWhen<TResult extends Object?>({
+ TResult Function()? initial,
+ TResult Function()? file,
+ TResult Function()? extract,
+ TResult Function()? transform,
+ TResult Function()? load,
+ TResult Function()? complete,
+ TResult Function()? error,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;ModuleStep get step => map(
+ initial: (_) => ModuleStep.initial,
+ file: (_) => ModuleStep.file,
+ extract: (_) => ModuleStep.extract,
+ transform: (_) => ModuleStep.transform,
+ load: (_) => ModuleStep.load,
+ complete: (_) => ModuleStep.complete,
+ error: (_) => ModuleStep.error,
+ );Map<String, dynamic> toJson() => throw _privateConstructorUsedError;@optionalTypeArgs
+TResult when<TResult extends Object?>({
+ required TResult Function() initial,
+ required TResult Function() file,
+ required TResult Function() extract,
+ required TResult Function() transform,
+ required TResult Function() load,
+ required TResult Function() complete,
+ required TResult Function() error,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? whenOrNull<TResult extends Object?>({
+ TResult? Function()? initial,
+ TResult? Function()? file,
+ TResult? Function()? extract,
+ TResult? Function()? transform,
+ TResult? Function()? load,
+ TResult? Function()? complete,
+ TResult? Function()? error,
+}) =>
+ throw _privateConstructorUsedError;[initial, file, extract, transform, load, complete, error]
+ A constant List of the values in this enum, in order of their declaration.
+const factory ModuleTransform() = _\$ModuleTransform;Moduler(
+ super.spec,
+ super.fileSpec, {
+ ModuleState state = const ModuleInitial(),
+}) {
+ _states = BehaviorSubject<ModuleState>.seeded(state);
+}@override
+ModuleState get currentState => _states.value;@override
+ModuleStep get currentStep => currentState.step;final FileSpec fileSpec;@override
+FutureOr<void> process(XFile file) async {
+ final fileBytes = await IFile.filer(spec, fileSpec).prepare(file);
+
+ _states.add(const ModuleState.extract());
+
+ final extracted = <String, dynamic>{};
+
+ for (final key in fileBytes.keys) {
+ final content = fileBytes[key];
+ if (content != null) extracted[key] = await _extract(content);
+ }
+
+ _states.add(const ModuleState.transform());
+
+ final transformed = <String, dynamic>{};
+
+ for (final extract in extracted.entries) {
+ transformed[extract.key] = await _transform(extract.value);
+ }
+
+ _states.add(const ModuleState.load());
+
+ for (final transform in transformed.entries) {
+ await _load(transform.value);
+ }
+
+ _states.add(const ModuleState.complete());
+}final ModuleSpec spec;@override
+Stream<ModuleState> get states => _states.stream;const PatternConverter();@override
+fromJson(_) {
+ switch (_['runtimeType']) {
+ case 'RegExp':
+ return RegExp(_['pattern']!);
+ case 'String':
+ return _['pattern']!;
+ default:
+ throw CheckedFromJsonException(_, 'runtimeType', 'Pattern',
+ 'Invalid union type "\${_['runtimeType']}"!');
+ }
+}@override
+toJson(_) {
+ switch (_.runtimeType) {
+ case RegExp:
+ return {
+ 'runtimeType': 'RegExp',
+ 'pattern': (_ as RegExp).pattern,
+ };
+ case String:
+ return {
+ 'runtimeType': 'String',
+ 'pattern': _ as String,
+ };
+ default:
+ throw StateError('Invalid union type "\${_.runtimeType}"!');
+ }
+}bool equals(other) {
+ if (this is RegExp && other is RegExp) {
+ return (this as RegExp).pattern == other.pattern;
+ } else if (this is String && other is String) {
+ return this == other;
+ }
+ return false;
+}bool matches(String value) {
+ if (this is RegExp) {
+ return (this as RegExp).hasMatch(value);
+ } else if (this is String) {
+ return this == value;
+ }
+ return false;
+}A constant List of the values in this enum, in order of their declaration.
+const RetrieveLocalFile();@override
+FutureOr<XFile?> retrieve() async {
+ final FilePickerResult? result = await XFilePicker.instance.pickFiles();
+
+ return result?.files.first.xFile;
+}const TransformJson(super.spec);@override
+FutureOr<Map<String, dynamic>> transform(Map<String, dynamic> data) =>
+ JsonNormalizer(spec.schema).normalizeWith(spec.schema.first, data);UnpackService({
+ required UnpackRepository repository,
+}) : _repo = repository {
+ _repo.watchAllStates().listen(_states.add);
+}int get activeInstances => _instances.length;FutureOr<void> clear() async =>
+ await Future.wait(_instances.keys.map(dispose));@override
+Future<void> dispose(String instanceId) async {
+ final instance = _instances[instanceId];
+ await instance?.dispose();
+ _instances.remove(instanceId);
+}@override
+Future<String> initialize(UnpackSpec spec) async =>
+ await _repo.putState(spec.initialState).then((_) => _.id!);@override
+Future<Iterable<UnpackSpec>> get specs => _repo.getAllSpecs();@override
+Stream<Iterable<UnpackState>> get states => _states.stream;@override
+Future<IUnpack> unpacker(String id) async {
+ if (_instances.containsKey(id)) return _instances[id]!;
+
+ final state = await _repo.getStateById(id);
+ final spec = await _repo.getSpecById(state.specId);
+
+ _instances[id] ??= Unpacker(spec, state: state);
+
+ return _instances[id]!;
+}const XFileConverter();@override
+fromJson(_) => XFile(_);@override
+toJson(_) => _.path;const ZipFile(super.moduleSpec);@override
+FutureOr<Map<String, Iterable<int>>> prepare(XFile file) async {
+ final archive = await _archives.putIfAbsent(
+ file.path, () => XZipDecoder.decodeXFile(file));
+
+ return <String, Iterable<int>>{
+ for (final file in archive.files)
+ if (moduleSpec.fileMatcher.matches(file.name)) file.name: file.content
+ };
+}flatten is similar to pandas' json_normalize function, this function +recursively flattens the nested JSON objects into a flat tabular list. +It returns List<Map<String, dynamic>> of the flattened records.
+Simple example:
+[
+ {"id": 1, "name": {"first": "Coleen", "last": "Volk"}},
+ {"name": {"given": "Mark", "family": "Regner"}},
+ {"id": 2, "name": "Faye Raker"},
+]
+flatten(input);
+Results in:
+[
+ {"id": 1, "name.first": "Coleen", "name.last": "Volk", "name.given": null, "name.family": null},
+ {"id": null, "name.first": null, "name.last": null, "name.given": "Mark", "name.family": "Regner"},
+ {"id": 2, "name": "Faye Raker", "name.first": null, "name.last": null, "name.given": null, "name.family": null},
+]
+Advanced example:
+[
+ {
+ "state": "Florida",
+ "shortname": "FL",
+ "info": {"governor": "Rick Scott"},
+ "counties": [
+ {"name": "Dade", "population": 12345},
+ {"name": "Broward", "population": 40000},
+ {"name": "Palm Beach", "population": 60000},
+ ],
+ },
+ {
+ "state": "Ohio",
+ "shortname": "OH",
+ "info": {"governor": "John Kasich"},
+ "counties": [
+ {"name": "Summit", "population": 1234},
+ {"name": "Cuyahoga", "population": 1337},
+ ],
+ },
+]
+flatten(input, recordPath: ["counties"], includePath: [["state"], ["shortname"], ["info", "governor"]]);
+Results in:
+[
+ {
+ "state": "Florida",
+ "shortname": "FL",
+ "info.governor": "Rick Scott",
+ "name": "Dade",
+ "population": 12345
+ },
+ {
+ "state": "Florida",
+ "shortname": "FL",
+ "info.governor": "Rick Scott",
+ "name": "Broward",
+ "population": 40000
+ },
+ {
+ "state": "Florida",
+ "shortname": "FL",
+ "info.governor": "Rick Scott",
+ "name": "Palm Beach",
+ "population": 60000
+ },
+ {
+ "state": "Ohio",
+ "shortname": "OH",
+ "info.governor": "John Kasich",
+ "name": "Summit",
+ "population": 1234
+ },
+ {
+ "state": "Ohio",
+ "shortname": "OH",
+ "info.governor": "John Kasich",
+ "name": "Cuyahoga",
+ "population": 1337
+ },
+]
+List<Map<String, dynamic>> flatten(
+ /// Json to flatten
+ dynamic json, {
+ /// Separator used to join the path of the nested keys
+ String separator = '.',
+
+ /// Json path of records in the given json. This will be the entry point for the flattening.
+ List<String> recordPath = const [],
+
+ /// Json path from the root of data to extract from the nested records.
+ /// Each path will become a column in the resulting table.
+ List<List<String>> includePath = const [],
+
+ /// Add missing fields or column to the records.
+ bool addMissingKeys = true,
+
+ // TODO: Implement maxLevel
+ /// Level of nesting to flatten
+ int maxLevel = -1,
+}) {
+ final result = <Map<String, dynamic>>[];
+ final seenKeys = addMissingKeys ? <String>{} : null;
+
+ final includeResult = <String, dynamic>{};
+ final includeKeys = includePath.map((i) => i.join(separator)).toSet();
+
+ final commonPath = includePath.isNotEmpty
+ ? (includePath
+ .map((i) => i
+ .headIntersect(recordPath)
+ // .whereNot((e) => e == '*')
+ .join(separator))
+ .toSet())
+ : const <String>{};
+
+ // if (kDebugMode) print(includeKeys);
+ // if (kDebugMode) print(commonPath);
+
+ _flatten(
+ json,
+ separator,
+ const [],
+ recordPath,
+ includeKeys,
+ commonPath,
+ maxLevel,
+ listAccumulator(result, seenKeys),
+ includeAccumulator(includeResult, includeKeys),
+ );
+
+ // if (kDebugMode) print(includeResult);
+
+ if (seenKeys != null) {
+ for (final e in result) {
+ for (final k in seenKeys) {
+ e.putIfAbsent(k, () => null);
+ }
+ }
+ }
+
+ return result;
+}typedef IFromJson<I> = Map<Type, I Function(Map<String, dynamic> json)>;Accumulator includeAccumulator(
+ Map<String, dynamic> result,
+ Set<String> includeKeys,
+) =>
+ (k, v) => result[k] = v;const jsonTypeKey = '@type';Accumulator listAccumulator<T>(
+ List<T> result, [
+ Set<String>? seenKeys,
+]) =>
+ (k, v) {
+ // if (kDebugMode) print('listAccumulator :: \$k :: \$v');
+ if (v is T) {
+ result.add(v);
+ } else if (result is List<Map<String, dynamic>>) {
+ result.cast<Map<String, dynamic>>().add({'value': v});
+ }
+
+ if (v is Map<String, dynamic>) seenKeys?.addAll(v.keys);
+ };Accumulator mapAccumulator(
+ Map<String, dynamic> result,
+) =>
+ (k, v) {
+ // if (kDebugMode) print('mapAccumulator :: \$k :: \$v');
+ v is Map<String, dynamic> ? result.addAll(v) : result[k] = v;
+ };dynamic /* String / Int */ normalize(
+ Map<String, dynamic> json,
+ JsonSchema schema,
+ AccumulatorCallback accumulator,
+ SchemaFinder find,
+) {
+ return schema.map(
+ entity: (schema) {
+ final result = <String, dynamic>{};
+ // final id = json[schema.key];
+
+ final resultSchema = schema.definition.entries
+ .groupListsBy(
+ (e) => e.value is JsonRefValue
+ ? (e.value as JsonRefValue).name
+ : e.key,
+ )
+ .map((key, value) => MapEntry(key, {
+ for (var d in value) d.key: d.value,
+ }));
+
+ json.forEach((k, v) {
+ final define = resultSchema[k];
+
+ if (define != null && define.isNotEmpty) {
+ define.forEach((target, schema) {
+ if (schema is ValueFrom) {
+ result[target] = v;
+ } else if (schema is SlugFrom) {
+ result[target] = slugify(v);
+ } else if (schema is IJsonSchemaRef) {
+ result[target] = normalizeRef(
+ v,
+ schema,
+ find,
+ accumulator,
+ );
+ }
+ });
+ } else {
+ result[k] = v;
+ }
+ });
+
+ accumulator(schema.name, json[schema.key].toString(), result);
+ return result[schema.key];
+ },
+ struct: (schema) {
+ json.forEach((key, value) {
+ final define = schema.definition[key];
+
+ if (define is IJsonSchemaRef) {
+ normalizeRef(
+ value,
+ define,
+ find,
+ accumulator,
+ );
+ } else if (define is Map && value is Map<String, dynamic>) {
+ normalize(
+ value,
+ schema.copyWith(definition: define),
+ accumulator,
+ find,
+ );
+ } else if (define is List && value is List) {
+ for (final value in value) {
+ normalize(
+ value,
+ schema.copyWith(definition: define.first),
+ accumulator,
+ find,
+ );
+ }
+ }
+ });
+
+ return schema.name;
+ },
+ flat: (schema) {
+ final flattened = flatten(json,
+ recordPath: schema.entityPath,
+ includePath: schema.includePath,
+ addMissingKeys: schema.addMissingKeys);
+
+ flattened.forEachIndexed((key, value) {
+ normalize(
+ value,
+ Entity(schema.name, definition: schema.definition),
+ accumulator,
+ find,
+ );
+ });
+ return schema.name;
+ },
+ );
+}dynamic /* List<String> / String */ normalizeRef(
+ dynamic json,
+ IJsonSchemaRef? define,
+ SchemaFinder find,
+ AccumulatorCallback accumulator,
+) {
+ if (define is JsonRefList && json is List) {
+ final ids = define.doCallback(
+ json,
+ (nextJson, nextScheme) {
+ final entity = nextScheme.getScheme(nextJson, find);
+ final id = normalize(
+ nextJson is Map<String, dynamic> ? nextJson : {'@value': nextJson},
+ entity,
+ accumulator,
+ find,
+ );
+ return nextScheme.useId(id, entity);
+ },
+ );
+ return ids;
+ } else if (define is JsonRef) {
+ final nextScheme = define.getScheme(json, find);
+ final id = normalize(json is Map<String, dynamic> ? json : {'@value': json},
+ nextScheme, accumulator, find);
+
+ return define.useId(id, nextScheme);
+ }
+
+ throw UnimplementedError();
+}'@type'
+ UnpackAssistantBloc({
+ required UnpackService unpackService,
+}) : _unpackService = unpackService,
+ super(const _Initial()) {
+ on<_SelectApp>(_onSelectApp);
+ on<_SelectArchive>(_onSelectArchive);
+ on<_SelectData>(_onSelectData);
+ on<_Start>(_onStart);
+}UnpackAssistantBloc is responsible for helping the user importing or +unpacking their exported archive from other apps. The assistant takes +the user through the following steps to help them import their data:
+Constraints:
+event which triggers
+all corresponding EventHandler instances.
+ error which triggers onError with an optional StackTrace.
+ event and state Streams.
+This method should be called when a Bloc is no longer needed.
+Once close is called, events that are added will not be
+processed.
+In addition, if close is called while events are still being
+processed, the Bloc will finish processing the pending events.
+ E.
+There should only ever be one event handler per event type E.
+ change occurs with the given change.
+A change occurs when a new state is emitted.
+onChange is called before the state of the cubit is updated.
+onChange is a great spot to add logging/analytics for a specific cubit.
+ error occurs and notifies BlocObserver.onError.
+ event is added to the Bloc.
+A great spot to add logging/analytics at the individual Bloc level.
+ transition occurs with the given transition.
+A transition occurs when a new event is added
+and a new state is emitted from a corresponding EventHandler.
+executed.
+onTransition is called before a Bloc's state has been updated.
+A great spot to add logging/analytics at the individual Bloc level.
+ Called whenever an error occurs and notifies BlocObserver.onError.
Note: super.onError should always be called last.
@override
+void onError(Object error, StackTrace stackTrace) {
+ // Custom onError logic goes here
+
+ // Always call super.onError with the current error and stackTrace
+ super.onError(error, stackTrace);
+}
+@override
+void onError(error, stackTrace) {
+ // TODO: implement analytics here
+ log("\$runtimeType - error", error: error, stackTrace: stackTrace);
+ super.onError(error, stackTrace);
+}Called whenever an event is added to the Bloc.
+A great spot to add logging/analytics at the individual Bloc level.
Note: super.onEvent should always be called first.
@override
+void onEvent(Event event) {
+ // Always call super.onEvent with the current event
+ super.onEvent(event);
+
+ // Custom onEvent logic goes here
+}
+See also:
+@override
+void onEvent(event) {
+ // TODO: implement analytics here
+ log("\$runtimeType - event : \$event");
+ super.onEvent(event);
+}typedef UnpackAssistantBuilder
+ = BlocBuilder<UnpackAssistantBloc, UnpackAssistantState>;typedef UnpackAssistantConsumer
+ = BlocConsumer<UnpackAssistantBloc, UnpackAssistantState>;User selected the archive file to be imported
+const factory UnpackAssistantEvent.selectArchive({
+ required XFile xFile,
+}) = _SelectArchive;UnpackAssistantEvent are the events that the UnpackAssistantBloc can +respond to.
+@optionalTypeArgs
+TResult map<TResult extends Object?>({
+ required TResult Function(_SelectApp value) selectApp,
+ required TResult Function(_SelectArchive value) selectArchive,
+ required TResult Function(_SelectData value) selectData,
+ required TResult Function(_Start value) start,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? mapOrNull<TResult extends Object?>({
+ TResult? Function(_SelectApp value)? selectApp,
+ TResult? Function(_SelectArchive value)? selectArchive,
+ TResult? Function(_SelectData value)? selectData,
+ TResult? Function(_Start value)? start,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeMap<TResult extends Object?>({
+ TResult Function(_SelectApp value)? selectApp,
+ TResult Function(_SelectArchive value)? selectArchive,
+ TResult Function(_SelectData value)? selectData,
+ TResult Function(_Start value)? start,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeWhen<TResult extends Object?>({
+ TResult Function(String app)? selectApp,
+ TResult Function(XFile xFile)? selectArchive,
+ TResult Function(List<String> data)? selectData,
+ TResult Function()? start,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult when<TResult extends Object?>({
+ required TResult Function(String app) selectApp,
+ required TResult Function(XFile xFile) selectArchive,
+ required TResult Function(List<String> data) selectData,
+ required TResult Function() start,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? whenOrNull<TResult extends Object?>({
+ TResult? Function(String app)? selectApp,
+ TResult? Function(XFile xFile)? selectArchive,
+ TResult? Function(List<String> data)? selectData,
+ TResult? Function()? start,
+}) =>
+ throw _privateConstructorUsedError;typedef UnpackAssistantListener
+ = BlocListener<UnpackAssistantBloc, UnpackAssistantState>;A description for UnpackAssistantPage
+const UnpackAssistantPage({super.key});A description for UnpackAssistantPage
+DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => BlocProvider(
+ create: (context) => UnpackAssistantBloc(
+ unpackService: UnpackService(
+ repository: context.read(),
+ ),
+ ),
+ child: const Scaffold(
+ body: UnpackAssistantView(),
+ ),
+ );typedef UnpackAssistantSelector<T>
+ = BlocSelector<UnpackAssistantBloc, UnpackAssistantState, T>;Sliver of the UnpackAssistantPage.
+Add what it does
+const UnpackAssistantSliver({super.key});Sliver of the UnpackAssistantPage.
+Add what it does
+DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) {
+ return BlocBuilder<UnpackAssistantBloc, UnpackAssistantState>(
+ builder: (context, state) {
+ return Center(child: Text(state.toString()));
+ },
+ );
+}Assistant has errored.
+const factory UnpackAssistantState.errored({
+ required final Object error,
+ required final StackTrace stackTrace,
+}) = _Errored;UnpackAssistantState are the states that the UnpackAssistantBloc can be.
+@optionalTypeArgs
+TResult map<TResult extends Object?>({
+ required TResult Function(_Initial value) initial,
+ required TResult Function(_Apps value) apps,
+ required TResult Function(_Archive value) archive,
+ required TResult Function(_Data value) data,
+ required TResult Function(_Processing value) processing,
+ required TResult Function(_Completed value) completed,
+ required TResult Function(_Errored value) errored,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? mapOrNull<TResult extends Object?>({
+ TResult? Function(_Initial value)? initial,
+ TResult? Function(_Apps value)? apps,
+ TResult? Function(_Archive value)? archive,
+ TResult? Function(_Data value)? data,
+ TResult? Function(_Processing value)? processing,
+ TResult? Function(_Completed value)? completed,
+ TResult? Function(_Errored value)? errored,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeMap<TResult extends Object?>({
+ TResult Function(_Initial value)? initial,
+ TResult Function(_Apps value)? apps,
+ TResult Function(_Archive value)? archive,
+ TResult Function(_Data value)? data,
+ TResult Function(_Processing value)? processing,
+ TResult Function(_Completed value)? completed,
+ TResult Function(_Errored value)? errored,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult maybeWhen<TResult extends Object?>({
+ TResult Function()? initial,
+ TResult Function(List<String> apps)? apps,
+ TResult Function()? archive,
+ TResult Function(List<String> data)? data,
+ TResult Function(int progress)? processing,
+ TResult Function()? completed,
+ TResult Function(Object error, StackTrace stackTrace)? errored,
+ required TResult orElse(),
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult when<TResult extends Object?>({
+ required TResult Function() initial,
+ required TResult Function(List<String> apps) apps,
+ required TResult Function() archive,
+ required TResult Function(List<String> data) data,
+ required TResult Function(int progress) processing,
+ required TResult Function() completed,
+ required TResult Function(Object error, StackTrace stackTrace) errored,
+}) =>
+ throw _privateConstructorUsedError;@optionalTypeArgs
+TResult? whenOrNull<TResult extends Object?>({
+ TResult? Function()? initial,
+ TResult? Function(List<String> apps)? apps,
+ TResult? Function()? archive,
+ TResult? Function(List<String> data)? data,
+ TResult? Function(int progress)? processing,
+ TResult? Function()? completed,
+ TResult? Function(Object error, StackTrace stackTrace)? errored,
+}) =>
+ throw _privateConstructorUsedError;View of the UnpackAssistantPage.
+Add what it does
+const UnpackAssistantView({super.key});View of the UnpackAssistantPage.
+Add what it does
+DiagnosticsNode objects describing this node's
+children.
+ Describes the part of the user interface represented by this widget.
+The framework calls this method when this widget is inserted into the tree +in a given BuildContext and when the dependencies of this widget change +(e.g., an InheritedWidget referenced by this widget changes). This +method can potentially be called in every frame and should not have any side +effects beyond building a widget.
+The framework replaces the subtree below this widget with the widget +returned by this method, either by updating the existing subtree or by +removing the subtree and inflating a new subtree, depending on whether the +widget returned by this method can update the root of the existing +subtree, as determined by calling Widget.canUpdate.
+Typically implementations return a newly created constellation of widgets +that are configured with information from this widget's constructor and +from the given BuildContext.
+The given BuildContext contains information about the location in the +tree at which this widget is being built. For example, the context +provides the set of inherited widgets for this location in the tree. A +given widget might be built with multiple different BuildContext +arguments over time if the widget is moved around the tree or if the +widget is inserted into the tree in multiple places at once.
+The implementation of this method must only depend on:
+context using
+BuildContext.dependOnInheritedWidgetOfExactType.If a widget's build method is to depend on anything else, use a +StatefulWidget instead.
+See also:
+@override
+Widget build(BuildContext context) => UnpackAssistantBuilder(
+ builder: (context, state) => Center(
+ child: Column(
+ children: [
+ Text(state.toString()),
+ ButtonText(
+ onPressed: () => XFilePicker.instance
+ .pickFiles(
+ type: FileType.custom,
+ allowedExtensions: ['zip'],
+ withData: false,
+ withReadStream: false,
+ )
+ .then(
+ (_) => context
+ .read<UnpackAssistantBloc>()
+ .add(UnpackAssistantEvent.selectArchive(
+ xFile: _!.files.single.xFile,
+ )),
+ ),
+ child: const Text('Select Archive'),
+ ),
+ ],
+ ),
+ ),
+ );Stream of Events as input
+and transforms them into a Stream of States as output.
+states.
+BlocBuilder is analogous to StreamBuilder but has simplified API to
+reduce the amount of boilerplate code needed as well as bloc-specific
+performance improvements.
+Please refer to BlocListener if you want to "do" anything in response to
+state changes such as navigation, showing a dialog, etc...
+BlocListener
+and BlocBuilder but reduces the amount of boilerplate needed.
+BlocConsumer should only be used when it is necessary to both rebuild UI
+and execute other reactions to state changes in the bloc.
+state changes in the bloc.
+It should be used for functionality that needs to occur only in response to
+a state change such as navigation, showing a SnackBar, showing
+a Dialog, etc...
+The listener is guaranteed to only be called once for each state change
+unlike the builder in BlocBuilder.
+BlocProvider.of(context).
+It is used as a dependency injection (DI) widget so that a single instance
+of a Bloc or Cubit can be provided to multiple widgets within a subtree.
+State to another.
+A Change consists of the currentState and nextState.
+child which will have access to the repository via
+RepositoryProvider.of(context).
+It is used as a dependency injection (DI) widget so that a single instance
+of a repository can be provided to multiple widgets within a subtree.
+read method.
+select method on BuildContext.
+watch method.
+buildWhen function which takes the previous state and
+the current state and is responsible for returning a bool which
+determines whether to rebuild BlocBuilder with the current state.
+
+
+ listenWhen function which takes the previous state
+and the current state and is responsible for returning a bool which
+determines whether or not to call BlocWidgetListener of BlocListener
+with the current state.
+
+
+ builder function which takes the BuildContext and
+state and is responsible for returning a widget which is to be rendered.
+This is analogous to the builder function in StreamBuilder.
+
+
+ listener function which takes the BuildContext along
+with the state and is responsible for executing in response to
+state changes.
+
+
+ selector function which
+is responsible for returning a selected value, T, based on state.
+
+
+ Event
+and can emit zero or more states via the Emitter.
+
+
+ An interface for UnpackRepository
+Future<Iterable<UnpackSpec>> getAllSpecs();Future<Iterable<UnpackState>> getAllStates();Future<UnpackSpec> getSpecById(String id);Future<UnpackState> getStateById(String id);Future<bool> get isSpecsEmpty;Future<bool> get isStatesEmpty;Future<UnpackSpec> putSpec(UnpackSpec spec);Future<UnpackState> putState(UnpackState state);Stream<Iterable<UnpackSpec>> watchAllSpecs();Stream<Iterable<UnpackState>> watchAllStates();UnpackRepository description
+const UnpackRepository(this._db);UnpackRepository description
+static Future<void> bootstrap(
+ UnDatabase db,
+ Iterable<UnpackSpec> specs,
+) async {
+ if (await db.unpackSpecDao.isEmpty) {
+ await db.unpackSpecDao.putAll(
+ specs.map(UnpackSpecMapper.modelToEntity),
+ );
+ }
+}@override
+Future<Iterable<UnpackSpec>> getAllSpecs() => _db.unpackSpecDao
+ .getAll()
+ .then((_) => _.map(UnpackSpecMapper.entityToModel));@override
+Future<Iterable<UnpackState>> getAllStates() => _db.unpackStateDao
+ .getAll()
+ .then((_) => _.map(UnpackStateMapper.entityToModel));@override
+Future<UnpackSpec> getSpecById(String id) =>
+ _db.unpackSpecDao.get(id).then(UnpackSpecMapper.entityToModel);@override
+Future<UnpackState> getStateById(String id) =>
+ _db.unpackStateDao.get(id).then(UnpackStateMapper.entityToModel);@override
+Future<bool> get isSpecsEmpty => _db.unpackSpecDao.isEmpty;@override
+Future<bool> get isStatesEmpty => _db.unpackStateDao.isEmpty;@override
+Future<UnpackSpec> putSpec(UnpackSpec spec) => _db.unpackSpecDao
+ .put(UnpackSpecMapper.modelToEntity(spec))
+ .then(UnpackSpecMapper.entityToModel);@override
+Future<UnpackState> putState(UnpackState state) => _db.unpackStateDao
+ .put(UnpackStateMapper.modelToEntity(state))
+ .then(UnpackStateMapper.entityToModel);@override
+Stream<Iterable<UnpackSpec>> watchAllSpecs() => _db.unpackSpecDao
+ .watchAll()
+ .map((_) => _.map(UnpackSpecMapper.entityToModel));@override
+Stream<Iterable<UnpackState>> watchAllStates() => _db.unpackStateDao
+ .watchAll()
+ .map((_) => _.map(UnpackStateMapper.entityToModel));static UnpackSpec entityToModel(UnpackSpecData data) => UnpackSpec(
+ id: data.id,
+ name: data.name,
+ fileSpec: FileSpec.fromJson(
+ jsonDecode(data.fileSpec),
+ ),
+ retrieveSpec: RetrieveSpec.fromJson(
+ jsonDecode(data.retrieveSpec),
+ ),
+ modules: (jsonDecode(data.modules) as Iterable)
+ .map((_) => ModuleSpec.fromJson(_)),
+ );static UnpackSpecCompanion modelToEntity(UnpackSpec model) =>
+ UnpackSpecCompanion.insert(
+ id: model.id != null ? Value(model.id!) : const Value.absent(),
+ slug: model.slug,
+ name: model.name,
+ fileSpec: jsonEncode(model.fileSpec),
+ retrieveSpec: jsonEncode(model.retrieveSpec),
+ modules: jsonEncode(model.modules),
+ );static UnpackState entityToModel(UnpackStateData data) => UnpackState(
+ id: data.id,
+ specId: data.specId,
+ step: UnpackStep.values.firstWhere((_) => _.name == data.step),
+ selectedModules: data.selectedModules != null
+ ? jsonDecode(data.selectedModules!)
+ : const [],
+ filePath: data.filePath,
+ );static UnpackStateCompanion modelToEntity(UnpackState model) =>
+ UnpackStateCompanion.insert(
+ id: model.id != null ? Value(model.id!) : const Value.absent(),
+ specId: model.specId,
+ step: model.step.name,
+ selectedModules: Value(jsonEncode(model.selectedModules)),
+ filePath: Value(model.filePath),
+ );const facebookModules = <ModuleSpec>[
+ adsTopics,
+ advertiserDataUse,
+ advertiserContactUpload,
+ advertiserInteraction,
+ externalActivities,
+ externalInstalls,
+ account,
+ inferredTopics,
+];const facebookSpec = UnpackSpec(
+ // id: 'id',
+ name: 'name',
+ fileSpec: FileSpec.zip(),
+ retrieveSpec: RetrieveSpec.localFile(),
+ modules: facebookModules,
+);const unpackSpecs = <UnpackSpec>[
+ facebookSpec,
+];<ModuleSpec>[adsTopics, advertiserDataUse, advertiserContactUpload, advertiserInteraction, externalActivities, externalInstalls, account, inferredTopics]
+ UnpackSpec(name: 'name', fileSpec: FileSpec.zip(), retrieveSpec: RetrieveSpec.localFile(), modules: facebookModules)
+ <UnpackSpec>[facebookSpec]
+