搜索插件、代码仓与 APP 分类

插件详情v2.8.6

solidart

一个简单的 Dart 应用状态管理解决方案,灵感来自 SolidJS

AndroidiOSWebmacOSWindowsLinux
近 30 天下载
6260
喜欢数
80
Pub 分数
150

安装插件

flutter pub add solidart

插件介绍

基于插件公开信息、社区数据与项目使用情况整理的选型参考。

Solidart 是一个轻量级的状态管理解决方案,适用于 Dart 应用程序,灵感来自 SolidJS。它提供响应式状态更新,且代码样板极少,可实现高效且可预测的 UI 渲染。通过利用细粒度的响应性,它确保在状态变化时仅重建必要的 UI 部分。设计上注重简洁与性能,Solidart 可无缝集成到跨多个平台的 Flutter 项目中。其 API 直观易用,使熟悉响应式编程模式的开发者能够轻松上手。

适合场景

  • Flutter 应用中的实时数据更新
  • 使用最少的重建构建响应式 UI
  • 简化复杂组件中的状态逻辑
  • 在多个小部件之间管理共享状态
  • 创建可扩展且可维护的应用架构

主要特点

  • 细粒度响应性
  • 最小化样板代码
  • 自动依赖跟踪
  • 跨平台支持(Android、iOS、Web、macOS、Windows、Linux)
  • 受 SolidJS 启发的简单 API

适合对象

  • 寻找 Provider 或 Riverpod 轻量级替代方案的开发者
  • 需要高性能状态更新的项目
  • 熟悉 SolidJS 或响应式编程的团队
  • 频繁更新 UI 和动态数据的应用
  • 初学者寻找一种直观的状态管理方法

使用建议

  • 与成熟的解决方案(如 Riverpod)相比,生态系统有限
  • 较少的社区文档和示例
  • 对于不熟悉响应式概念的人来说,可能需要一定的学习曲线
  • 在没有仔细架构的情况下,不适合非常大规模的状态树
  • 最适合对性能和简单性要求高于复杂工具的应用程序

原始 README

以下为关联源码仓库的 README 原文快照,最新内容请访问源码仓库。

License: MIT GitHub stars Coverage GitHub issues GitHub pull-requests solidart Pub Version flutter_solidart Pub Version All Contributors

A simple state-management library inspired by SolidJS.

The objectives of this project are:

  1. Being simple and easy to learn
  2. Fits well with the framework's good practices
  3. Do not have a single global state, but multiple states only in the most appropriate places
  4. No code generation

Learning

For a comprehensive and updated documentation go to The Official Documentation

There are 5 main concepts you should be aware:

  1. Signal
  2. Effect
  3. Computed
  4. Resource
  5. Dependency Injection
Signal

Signals are the cornerstone of reactivity in solidart. They contain values that change over time; when you change a signal's value, it automatically updates anything that uses it.

To create a signal, you have to use the Signal class:

final counter = Signal(0);

The argument passed to the class is the initial value, and the return value is the signal.

To retrieve the current value, you can use:

print(counter.value); // prints 0

To change the value, you can use:

// Set the value to 2
counter.value = 2;
// Update the value based on the current value
counter.updateValue((value) => value * 2);
Effect

Signals are trackable values, but they are only one half of the equation. To complement those are observers that can be updated by those trackable values. An effect is one such observer; it runs a side effect that depends on signals.

An effect can be created by using the Effect class. The effect automatically subscribes to any signal and reruns when any of them change. So let's create an Effect that reruns whenever counter changes:

final disposeFn = Effect(() {
    print("The count is now ${counter.value}");
});
Computed

A computed signal is a signal that depends on other signals. To create a computed signal, you have to use the Computed class.

A Computed automatically subscribes to any signal provided and reruns when any of them change.

final count = Signal(0);
final doubleCount = Computed(() => count.value * 2);

Effect(() {
  print('The counter is ${count.value}');
  print('The double counter is ${doubleCount.value}');
});

count
  ..value = 1
  ..value = 2;

// The output will be:
// The counter is 0
// The double counter is 0
// The counter is 1
// The double counter is 2
// The counter is 2
// The double counter is 4
Resource

Resources are special Signals designed specifically to handle Async loading. Their purpose is wrap async values in a way that makes them easy to interact with.

Resources can be driven by a source signal that provides the query to an async data fetcher function that returns a Future.

The contents of the fetcher function can be anything. You can hit typical REST endpoints or GraphQL or anything that generates a future. Resources are not opinionated on the means of loading the data, only that they are driven by futures.

Let's create a Resource:

// The source
final userId = Signal(1);

// The fetcher
Future<String> fetchUser() async {
    final response = await http.get(
      Uri.parse('https://jsonplaceholder.typicode.com/users/${userId.value}/'),
      headers: {'Accept': 'application/json'},
    );
    return response.body;
}

// The resource
final user = Resource(fetchUser, source: userId);

A Resource can also be driven from a Stream instead of a Future, and can be created with Resource.stream(() => stream). In this case you just need to pass the stream field to the Resource class.

If you're using SignalBuilder you can react to the state of the resource:

SignalBuilder(
  builder: (_, __) {
    return user.state.when(
      ready: (data) {
        return Column(
          mainAxisSize: MainAxisSize.min,
          children: [
            ListTile(
              title: Text(data),
              subtitle:
                  Text('refreshing: ${userState.isRefreshing}'),
            ),
            userState.isRefreshing
                ? const CircularProgressIndicator()
                : ElevatedButton(
                    onPressed: user.refresh,
                    child: const Text('Refresh'),
                  ),
          ],
        );
      },
      error: (e, _) {
        return Column(
          mainAxisSize: MainAxisSize.min,
          children: [
            Text(e.toString()),
            userState.isRefreshing
                ? const CircularProgressIndicator()
                : ElevatedButton(
                    onPressed: user.refresh,
                    child: const Text('Refresh'),
                  ),
          ],
        );
      },
      loading: () {
        return const RepaintBoundary(
          child: CircularProgressIndicator(),
        );
      },
    );
  },
)

The on method forces you to handle all the states of a Resource (ready, error and loading). The are also other convenience methods to handle only specific states.

Dependency Injection

The dependency injection in flutter_solidart is done using the disco package.

This replaced the Solid widget which was used in the previous versions of flutter_solidart.

disco has been built on top of Solid to provide a more powerful and flexible way to handle dependency injection.

Refer to the official disco documentation which contains also examples written with flutter_solidart

DevTools

You can debug your application using the Solidart DevTools extension and filter your signals.

Contributors

Alexandru Mariuti
Alexandru Mariuti

💻 🐛 🚧 💬 👀 📖 ⚠️
manuel-plavsic
manuel-plavsic

💻
Luke Greenwood
Luke Greenwood

📖
9dan
9dan

💻 🐛 📖
Seven Du
Seven Du

💻 🐛 📖
Haresh Gediya
Haresh Gediya

💻

所属分类

依赖

依赖清单 3 项

源码仓库

使用此插件的项目

暂无相关数据。