jet library

JetX is an extra-light and powerful multi-platform framework. It combines high performance state management, intelligent dependency injection, and route management in a quick and practical way.

Classes

BackButtonCallback
Bind<T>
BindElement<T>
The BindElement is responsible for injecting dependencies into the widget tree so that they can be observed
Binder<T>
Binding
Binding should be extended. When using JetMaterialApp, all JetPages and navigation methods (like Jet.to()) have a binding property that takes an instance of Bindings to manage the dependencies() (via Jet.put()) for the Route you are opening.
Bindings
Bindings should be extended or implemented. When using JetMaterialApp, all JetPages and navigation methods (like Jet.to()) have a binding property that takes an instance of Bindings to manage the dependencies() (via Jet.put()) for the Route you are opening.
BindingsInterface<T>
Binds
BlurAnimation
BounceAnimation
CircularRevealClipper
CircularRevealTransition
ColorAnimation
Computed<T>
A computed observable that automatically tracks dependencies and recomputes when any of its dependencies change.
CustomStatus<T>
CustomTransition
DeepCollectionEquality
DefaultEquality<E>
Dependencies
EmptyStatus<T>
Engine
ErrorStatus<T, S>
FadeInAnimation
FadeInTransition
FadeOutAnimation
FastList<T>
FlipAnimation
FormData
FullLifeCycleController
A controller that can observe the full app lifecycle.
GetBackGestureController<T>
GetBackGestureDetector<T>
GetBackGestureDetectorState<T>
GetConnect
GetCupertinoApp
GetDelegate
GetInformationParser
GetListenable<T>
GetMicrotask
GetMiddleware
The Page Middlewares. The Functions will be called in this order (( redirect -> onPageCalled -> onBindingsStart -> onPageBuildStart -> onPageBuilt -> onPageDispose ))
GetModalBottomSheetRoute<T>
GetNavigator
GetNotifier<T>
GetNotifier has a native status and state implementation, with the Get Lifecycle
GetObserver
GetQueue
GetRouterOutlet
GetStatus<T>
GraphQLResponse<T>
HeaderValue
IdentityEquality<E>
Equality of objects that compares only the identity of the objects.
IEquality<E>
A generic equality relation on objects.
IndexedRouteBuilder<T>
InheritedNavigator
InstanceInfo
IterableEquality<E>
Equality on iterables.
JetAnimatedBuilder<T>
JetAnimatedBuilderState<T>
JetBuilder<T extends JetxController>
JetConnectInterface
JetHttpClient
JetInterface
JetInterface allows any auxiliary package to be merged into the "Jet" class through extensions
JetMaterialApp
JetPage<T>
JetPageRoute<T>
JetPlatform
JetResponsiveView<T>
Extend this widget to build responsive view. this widget contains the screen property that have all information about the screen size and type. You have two options to build it. 1- with builder method you return the widget to build. 2- with methods desktop, tablet,phone, watch. the specific method will be built when the screen type matches the method when the screen is ScreenType.Tablet the tablet method will be exuded and so on. Note if you use this method please set the property alwaysUseBuilder to false With settings property you can set the width limit for the screen types.
JetResponsiveWidget<T extends JetLifeCycleMixin>
JetSnackBar
JetSnackBarState
JetSocket
JetUtils
JetView<T>
JetView is a great way of quickly access your Controller without having to call Jet.find<AwesomeController>() yourself.
JetWidget<S extends JetLifeCycleMixin>
JetWidget is a great way of quickly access your individual Controller without having to call Jet.find<AwesomeController>() yourself. Jet save you controller on cache, so, you can to use Jet.create() safely JetWidget is perfect to multiples instance of a same controller. Each JetWidget will have your own controller, and will be call events as onInit and onClose when the controller get in/get out on memory.
JetX<T extends JetLifeCycleMixin>
JetxController
A base controller class that provides state management functionality.
JetxService
Unlike JetxController, which serves to control events on each of its pages, JetxService is not automatically disposed (nor can be removed with Jet.delete()). It is ideal for situations where, once started, that service will remain in memory, such as Auth control for example. Only way to remove it is Jet.reset().
JetXState<T extends JetLifeCycleMixin>
LeftToRightFadeTransition
ListEquality<E>
Equality on lists.
LoadingStatus<T>
MapEquality<K, V>
Equality on maps.
MiddlewareRunner
MiniStream<T>
MiniSubscription<T>
Module
ModuleState
MultipartFile
Node<T>
NoTransition
Observer
Obx
The simplest reactive widget in JetX.
ObxElement
ObxError
ObxStatelessWidget
A StatelessWidget than can listen reactive changes.
ObxValue<T extends RxInterface>
Similar to Obx, but manages a local state. Pass the initial data in constructor. Useful for simple local states, like toggles, visibility, themes, button states, etc. Sample: ObxValue((data) => Switch( value: data.value, onChanged: (flag) => data.value = flag, ), false.obs, ),
ObxWidget
The ObxWidget is the base for all JetX reactive widgets
OpacityAnimation
PageRedirect
PageSettings
ParseRouteTree
PathDecoded
Response<T>
ResponsiveScreen
ResponsiveScreenSettings
RightToLeftFadeTransition
RotateAnimation
RouteDecoder
RouteListenerState
RouteReport
RouteReportState
RouterListener
RouterListenerInherited
RouterListenerState
RouterOutlet<TDelegate extends RouterDelegate<T>, T extends Object>
RouterOutletState<TDelegate extends RouterDelegate<T>, T extends Object>
Routing
Rx<T>
Foundation class used for custom Types outside the common native Dart types. For example, any custom "Model" class, like User().obs will use Rx as wrapper.
RxBool
RxController
A base controller class for reactive state management using Rx variables.
RxDouble
RxInt
RxInterface<T>
This class is the foundation for all reactive (Rx) classes that makes Get so powerful. This interface is the contract that _RxImpl<T> uses in all it's subclass.
RxList<E>
Create a list similar to List<T>
RxMap<K, V>
Rxn<T>
RxnBool
RxnDouble
RxnInt
RxnNum
RxnString
Rx class for String Type.
RxNum
RxSet<E>
RxString
Rx class for String Type.
ScaleAnimation
SetEquality<E>
Equality of sets.
SizeAnimation
SizeTransitions
SlideAnimation
SlideDownTransition
SlideInDownAnimation
SlideInLeftAnimation
SlideInRightAnimation
SlideInUpAnimation
SlideLeftTransition
SlideRightTransition
SlideTopTransition
SnackbarController
SnackBarQueue
SpinAnimation
StateController<T>
A controller that manages state for asynchronous operations.
SuccessStatus<T>
SuperController<T>
A controller that combines full lifecycle management with state management.
Translations
TrustedCertificate
UnorderedIterableEquality<E>
Equality of the elements of two iterables without considering order.
Value<T>
ValueBuilder<T>
Manages a local state like ObxValue, but uses a callback instead of a Rx value.
ValueBuilderState<T>
WaveAnimation
WobbleAnimation
Worker
Workers
ZoomInTransition

Enums

PopMode
Enables the user to customize the intended pop behavior
PreventDuplicateHandlingMode
Enables the user to customize the behavior when pushing multiple routes that shouldn't be duplicates
RowStyle
ScreenType
SmartManagement
Defines how JetX manages the lifecycle and disposal of controllers and dependencies.
SnackbarStatus
Indicates Status of snackbar SnackbarStatus.OPEN Snack is fully open, SnackbarStatus.CLOSED Snackbar has closed, SnackbarStatus.OPENING Starts with the opening animation and ends with the full snackbar display, SnackbarStatus.CLOSING Starts with the closing animation and ends with the full snackbar dispose
SnackHoverState
Indicates if the mouse entered or exited
SnackPosition
Indicates if snack is going to start at the TOP or at the BOTTOM
SnackStyle
Indicates if snack will be attached to the edge of the screen or not
Transition

Mixins

Equality
FullLifeCycleMixin
A mixin that provides full lifecycle callbacks for the controller.
GetSingleTickerProviderStateMixin
Used like SingleTickerProviderMixin but only with Get Controllers. Simplifies AnimationController creation inside JetxController.
GetTickerProviderStateMixin
Used like TickerProviderMixin but only with Get Controllers. Simplifies multiple AnimationController creation inside JetxController.
IGetNavigation
JetLifeCycleMixin
The GetLifeCycle
JetPageRouteTransitionMixin<T>
JetResponsiveMixin
JetxServiceMixin
Allow track difference between JetxServices and JetxControllers
PageRouteReportMixin<T>
RouteReportMixin<T extends StatefulWidget>
RouterListenerMixin<T extends StatefulWidget>
RxObjectMixin<T>
global object that registers against JetX and Obx, and allows the reactivity of those Widgets and Rx values.
ScrollMixin
A mixin that provides scroll-based data fetching capabilities.
SingleGetTickerProviderMixin
Used like SingleTickerProviderMixin but only with Get Controllers. Simplifies AnimationController creation inside JetxController.
StatelessObserverComponent
a Component that can track changes in a reactive variable
StateMixin<T>

Constants

rtlLanguages → const List<String>

Properties

Jet → _JetImpl
final
It replaces the Flutter Navigator, but needs no context. You can to use navigator.push(YourRoute()) rather Navigator.push(context, YourRoute());
no setter

Functions

bodyBytesToString(Stream<List<int>> bodyBytes, Map<String, String> headers) → Future<String>
debounce<T>(GetListenable<T> listener, WorkerCallback<T> callback, {Duration? time, Function? onError, void onDone()?, bool? cancelOnError}) → Worker
debounce is similar to interval, but sends the last value. Useful for Anti DDos, every time the user stops typing for 1 second, for instance. When listener emits the last "value", when time hits, it calls callback with the last "value" emitted.
defaultLogWriterCallback(String value, {bool isError = false}) → void
default logger from JetX
ever<T>(GetListenable<T> listener, WorkerCallback<T> callback, {dynamic condition = true, Function? onError, void onDone()?, bool? cancelOnError}) → Worker
Called every time listener changes. As long as the condition returns true.
everAll(List<RxInterface> listeners, WorkerCallback callback, {dynamic condition = true, Function? onError, void onDone()?, bool? cancelOnError}) → Worker
Similar to ever, but takes a list of listeners, the condition for the callback is common to all listeners, and the callback is executed to each one of them. The Worker is common to all, so worker.dispose() will cancel all streams.
interval<T>(GetListenable<T> listener, WorkerCallback<T> callback, {Duration time = const Duration(seconds: 1), dynamic condition = true, Function? onError, void onDone()?, bool? cancelOnError}) → Worker
Ignore all changes in listener during time (1 sec by default) or until condition is met (can be a bool expression or a bool Function()), It brings the 1st "value" since the period of time, so if you click a counter button 3 times in 1 sec, it will show you "1" (after 1 sec of the first press) click counter 3 times in 1 sec, it will show you "4" (after 1 sec) click counter 2 times in 1 sec, it will show you "7" (after 1 sec).
once<T>(GetListenable<T> listener, WorkerCallback<T> callback, {dynamic condition = true, Function? onError, void onDone()?, bool? cancelOnError}) → Worker
once() will execute only 1 time when condition is met and cancel the subscription to the listener stream right after that. condition defines when callback is called, and can be a bool or a bool Function().
removeLastHistory(String? url) → void
setUrlStrategy() → void

Typedefs

AsyncInstanceBuilderCallback<S> = Future<S> Function()
BindingBuilderCallback = void Function()
Decoder<T> = T Function(dynamic data)
FuturizeCallback<T> = Future<T> Function(VoidCallback fn)
GetRouteAwarePageBuilder<T> = Widget Function([JetPageRoute<T>? route])
InitBuilder<T> = T Function()
InstanceBuilderCallback<S> = S Function()
InstanceCreateBuilderCallback<S> = S Function(BuildContext _)
JetControllerBuilder<T extends JetLifeCycleMixin> = Widget Function(T controller)
JetPageBuilder = Widget Function()
JetXControllerBuilder<T extends JetLifeCycleMixin> = Widget Function(T controller)
LogWriterCallback = void Function(String text, {bool isError})
VoidCallback from logs
NotifierBuilder<T> = Widget Function(T state)
OffsetBuilder = Offset Function(BuildContext, double)
OnHover = void Function(JetSnackBar snack, SnackHoverState snackHoverState)
OnTap = void Function(JetSnackBar snack)
PrintFunctionCallback = void Function(String prefix, dynamic value, String info, {bool? isError})
Progress = dynamic Function(double percent)
ResponseInterceptor<T> = Future<Response<T>?> Function(Request<T> request, Type targetType, HttpClientResponse response)
SnackbarStatusCallback = void Function(SnackbarStatus? status)
ValueBuilderBuilder<T> = Widget Function(T snapshot, ValueBuilderUpdateCallback<T> updater)
ValueBuilderUpdateCallback<T> = void Function(T snapshot)
ValueUpdater<T> = T Function()
VoidCallback = void Function()
WidgetCallback = Widget Function()
WorkerCallback<T> = dynamic Function(T callback)

Exceptions / Errors

BindError<T>