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

插件详情v2.7.4

flutter_solidart

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

AndroidiOSWebmacOSWindowsLinux
近 30 天下载
6340
喜欢数
82
Pub 分数
160

安装插件

flutter pub add flutter_solidart

插件介绍

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

flutter_solidart 是一个轻量级的 Flutter 状态管理解决方案,灵感来自 SolidJS 的响应式编程模型。它实现了细粒度的响应式更新,只有受状态变化影响的 UI 部分才会重新构建,从而提升性能。该包使用响应式变量和派生值来简化状态更新,无需样板代码。它与 Flutter 的组件树无缝集成,并支持所有主要平台。专为寻求简单、高效替代传统状态管理方法的开发者设计。

适合场景

  • 表单中的实时数据更新
  • 通过最少的重建实现高效的UI更新
  • 中小型应用中的简单响应式逻辑
  • 跨多个组件的状态共享
  • 构建响应式仪表板
  • 轻量级状态管理,无需复杂设置

主要特点

  • 细粒度响应性
  • 最小化样板代码
  • 响应式变量和派生状态
  • 自动依赖跟踪
  • 支持所有 Flutter 平台
  • 与现有控件的轻松集成

适合对象

  • 熟悉响应式编程的开发者
  • 需要快速UI更新的项目
  • 避免使用重型状态管理框架的应用程序
  • 偏好简单而非复杂
  • 快速原型设计用户界面交互
  • 小型到中型 Flutter 应用程序

使用建议

  • 不适合具有复杂状态的大型应用
  • 与成熟的替代方案相比,文档有限
  • 对于不熟悉响应式模式的用户来说,学习曲线较陡
  • 比流行的状态管理器社区支持少
  • 可能需要仔细处理副作用
  • 最适合频繁但局部状态变更的应用程序

原始 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 项

源码仓库

使用此插件的项目