Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/contributors-company/pike
https://github.com/contributors-company/pike
Last synced: 29 days ago
JSON representation
- Host: GitHub
- URL: https://github.com/contributors-company/pike
- Owner: contributors-company
- License: mit
- Created: 2024-12-08T23:23:46.000Z (about 1 month ago)
- Default Branch: main
- Last Pushed: 2024-12-08T23:39:54.000Z (about 1 month ago)
- Last Synced: 2024-12-09T00:28:20.652Z (about 1 month ago)
- Language: Dart
- Size: 7.81 KB
- Stars: 1
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
README
# Pike
`Pike` is a state management library for Flutter based on the **Event-Driven** pattern. It uses event streams to manage state and provides convenient components for interacting with the state, such as `PikeBuilder`, `PikeConsumer`, and `PikeProvider`.
## Features
- **State management using events**: The state is updated in response to events.
- **Components for listening to and displaying state**: `PikeBuilder`, `PikeConsumer`, and `PikeProvider` are used to manage and display state changes.
- **Customizable event handling**: Allows for custom event handlers and selective state rebuilds.
## Installation
Add `pike` to your `pubspec.yaml` file:
```yaml
dependencies:
pike: ^latest_version
```
## Usage
### Creating a Pike instance
Create a `Pike` instance by passing an initial state:
```dart
final class MockPike extends Pike {
MockPike() : super(InitialState()) {
on((event, emit) => switch(event) {
FetchEvent() => _callback(event, emit),
FetchWithExceptionEvent() => _callbackA(event, emit),
});
}
Future _callback(FetchEvent event, Emit emit) async {
emit(LoadedState());
}
void _callbackA(FetchWithExceptionEvent event, Emit emit) {
emit(ExceptionState());
}
}
// Events
sealed class Event {}
class FetchEvent extends Event {}
class FetchWithExceptionEvent extends Event {}
// States
sealed class State {}
class InitialState extends State {}
class LoadedState extends State {}
class ExceptionState extends State {}
```
### Adding events
Add events to the `Pike` instance to trigger state changes:
```dart
pike.add(MyEvent());
```
### Listening to state changes
Use `PikeBuilder` or `PikeConsumer` to rebuild your widgets when the state changes:
```dart
PikeBuilder(
builder: (context, state) {
return Text('Current State: $state');
},
);
```
### Providing the Pike instance
Wrap your widget tree with `PikeProvider` to provide the `Pike` instance to the widgets:
```dart
PikeProvider(
pike: pike,
child: MyWidget(),
);
```
### Custom event handling with `PikeObserver`
You can implement `PikeObserver` to track the lifecycle and events of your `Pike` instances:
```dart
class MyPikeObserver extends PikeObserver {
@override
void onCreate
>(P pike) {
print("Pike created");
}
@override
void onEvent
, Event>(
P pike,
Event event,
) {
print("Event occurred: $event");
}
}
```
## Components
### `PikeBuilder`
A widget that listens to state changes and rebuilds when the state updates.
```dart
PikeBuilder(
builder: (context, state) {
return Text('Current State: $state');
},
);
```
### `PikeConsumer`
A widget that listens to state changes and provides a custom listener to trigger side effects.
```dart
PikeConsumer(
builder: (context, state) {
return Text('Current State: $state');
},
listener: (context, state) {
// Handle side effects here
},
);
```
### `PikeProvider`
A widget that provides a `Pike` instance to its descendants.
```dart
PikeProvider(
pike: pike,
child: MyWidget(),
);
```
## Codecov
