Solidart

https://solidart.mariuti.com
Admin
Solidart is a free, open-source state-management library for Dart and Flutter applications, inspired...
Tokens:12,380
Snippets:111
Trust Score:5.2
Update:8 months ago
Show doc for...
Tokens:
Raw
### Install solidart Package (Dart)

Source: https://solidart.mariuti.com/getting-started/setup

Installs the core Solidart reactive primitive library for Dart applications. This is the foundational package for reactive programming in Dart with Solidart.

```bash
dart pub add solidart
```

--------------------------------

### Basic Solidart Hooks Example with SignalBuilder

Source: https://solidart.mariuti.com/flutter/solidart_hooks

Demonstrates the basic usage of useSignal, useComputed, and useSolidartEffect within a HookWidget. It utilizes SignalBuilder for efficient UI updates when signal values change.

```dart
import 'package:flutter/material.dart';
import 'package:flutter_hooks/flutter_hooks.dart';
import 'package:solidart_hooks/solidart_hooks.dart';


class Example extends HookWidget {
  const Example({super.key});


  @override
  Widget build(BuildContext context) {
    final count = useSignal(0);
    final doubleCount = useComputed(() => count.value * 2);
    useSolidartEffect(() {
      debugPrint('Effect count: ${count.value}, doubleCount: ${doubleCount.value}');
    });
    return Scaffold(
      body: Center(
        child: SignalBuilder(
          builder: (context, child) {
            return Column(
              mainAxisAlignment: MainAxisAlignment.center,
              children: [
                Text('Count: ${count.value}'),
                Text('Double: ${doubleCount.value}'),
              ],
            );
          }
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => count.value++,
        child: const Icon(Icons.add),
      ),
    );
  }
}

```

--------------------------------

### Partial Widget Rebuild with HookBuilder and useListenable

Source: https://solidart.mariuti.com/flutter/solidart_hooks

Demonstrates how to achieve a partial widget rebuild using HookBuilder combined with useListenable. This is an alternative to SignalBuilder for targeted UI updates.

```dart
class UseSignalExample extends HookWidget {
  const UseSignalExample({super.key});


  @override
  Widget build(BuildContext context) {
    final count = useSignal(0);


    return Scaffold(
      appBar: AppBar(title: const Text('useSignal')),
      body: Center(
        child: HookBuilder(
          builder: (context) {
            useListenable(count);
            return Text('Count: ${count.value}');
          },
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => count.value++,
        child: const Icon(Icons.add),
      ),
    );
  }
}

```

--------------------------------

### Install solidart_hooks Package (Flutter)

Source: https://solidart.mariuti.com/getting-started/setup

Installs the solidart_hooks package, providing Flutter Hooks bindings for Solidart. This package helps reduce boilerplate code for managing ephemeral state.

```bash
flutter pub add solidart_hooks
```

--------------------------------

### Install flutter_solidart Package (Flutter)

Source: https://solidart.mariuti.com/getting-started/setup

Installs the flutter_solidart package, which extends Solidart's capabilities for use within Flutter applications. This package provides Flutter-specific integrations.

```bash
flutter pub add flutter_solidart
```

--------------------------------

### Use Resource in Flutter HookWidget

Source: https://solidart.mariuti.com/flutter/solidart_hooks

Explains how to create and manage asynchronous data fetching using useResource within a HookWidget. This hook handles loading, error, and ready states for resources, with automatic disposal upon widget unmounting.

```dart
class Example extends HookWidget {
  @override
  Widget build(BuildContext context) {
    final userResource = useResource(() async {
      await Future.delayed(const Duration(seconds: 1));
      return 'Data loaded';
    });


    return Scaffold(
      body: Center(
        child: SignalBuilder(
          builder: (context, child) {
            return userResource.state.when(
              ready: (data) => Text('Result: $data'),
              error: (error, stackTrace) => Text('Error: $error'),
              loading: () => const CircularProgressIndicator(),
            );
          },
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => userResource.refresh(),
        child: const Icon(Icons.refresh),
      ),
    );
  }
}
```

--------------------------------

### Creating a Computed Signal with useComputed in a HookWidget

Source: https://solidart.mariuti.com/flutter/solidart_hooks

Shows how to create a computed signal that derives its value from another signal using the useComputed hook. The UI updates automatically when the source signal changes.

```dart
class Example extends HookWidget {
  @override
  Widget build(BuildContext context) {
    final count = useSignal(5);
    final doubled = useComputed(() => count.value * 2);
    return Scaffold(
      body: Center(
        child: SignalBuilder(
          builder: (context, child) {
            return Column(
              mainAxisAlignment: MainAxisAlignment.center,
              children: [
                Text('Count: ${count.value}'),
                Text('Doubled: ${doubled.value}'),
              ],
            );
          },
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => count.value++,
        child: const Icon(Icons.add),
      ),
    );
  }
}

```

--------------------------------

### Rebuilding Widget with useListenable for Signal Changes

Source: https://solidart.mariuti.com/flutter/solidart_hooks

Shows how to use useListenable from flutter_hooks to react to signal changes. This approach rebuilds the entire widget tree when the signal's value changes.

```dart
class UseSignalExample extends HookWidget {
  const UseSignalExample({super.key});


  @override
  Widget build(BuildContext context) {
    final count = useSignal(0);
    // this will rebuild the entire widget when the signal changes
    useListenable(count);


    return Scaffold(
      appBar: AppBar(title: const Text('useSignal')),
      body: Center(child: Text('Count: ${count.value}')),
      floatingActionButton: FloatingActionButton(
        onPressed: () => count.value++,
        child: const Icon(Icons.add),
      ),
    );
  }
}

```

--------------------------------

### Creating a Signal with useSignal in a HookWidget

Source: https://solidart.mariuti.com/flutter/solidart_hooks

Illustrates how to create and manage a simple signal using the useSignal hook within a Flutter HookWidget. The UI automatically rebuilds when the signal's value is updated.

```dart
class Example extends HookWidget {
  @override
  Widget build(BuildContext context) {
    final count = useSignal(0);
    return Scaffold(
      body: Center(
        child: SignalBuilder(
          builder: (context, child) {
            return Text('Count: ${count.value}');
          },
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => count.value++,
        child: const Icon(Icons.add),
      ),
    );
  }
}

```

--------------------------------

### Use Map Signal in Flutter HookWidget

Source: https://solidart.mariuti.com/flutter/solidart_hooks

Demonstrates the usage of useMapSignal for reactive key-value pair management within a HookWidget. Changes to the map trigger UI rebuilds, and the signal is disposed when the widget is unmounted.

```dart
class Example extends HookWidget {
  @override
  Widget build(BuildContext context) {
    final userRoles = useMapSignal<String, String>({'admin': 'John'});
    return Scaffold(
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            SignalBuilder(
              builder: (context, child) {
                return Text(
                  'Roles: ${userRoles.value.entries.map((e) => '${e.key}:${e.value}').join(', ')}',
                );
              },
            ),
          ],
        ),
      )
      floatingActionButton: FloatingActionButton(
        onPressed: () => userRoles['user${userRoles.value.length}'] = 'User${userRoles.value.length}',
        child: const Icon(Icons.add),
      ),
    );
  }
}
```

--------------------------------

### Bind Existing Signal in Hook Widget (Dart)

Source: https://solidart.mariuti.com/flutter/solidart_hooks

Illustrates how to bind an existing Signal to a HookWidget using the useExistingSignal hook. This allows the widget to react to changes in the external signal. The example shows updating the signal's value via a FloatingActionButton. The signal is manually disposed when the widget is unmounted, unless autoDispose is set to true.

```dart
class UseExistingSignalExample extends StatefulHookWidget {
  const UseExistingSignalExample({super.key});


  @override
  State<UseExistingSignalExample> createState() =>
      _UseExistingSignalExampleState();
}


class _UseExistingSignalExampleState extends State<UseExistingSignalExample> {
  final existingSignal = Signal(42);


  @override
  Widget build(BuildContext context) {
    final boundSignal = useExistingSignal(existingSignal);


    return Scaffold(
      body: Center(
        child: SignalBuilder(
          builder: (context, child) {
            return Text('Value: ${boundSignal.value}');
          },
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => existingSignal.value++,
        child: const Icon(Icons.add),
      ),
    );
  }


  @override
  void dispose() {
    existingSignal.dispose();
    super.dispose();
  }
}

```

--------------------------------

### Create Resource Stream in Hook Widget (Dart)

Source: https://solidart.mariuti.com/flutter/solidart_hooks

Demonstrates how to create a new resource from a stream within a HookWidget using the useResourceStream hook. It handles different states of the stream (ready, error, loading) and provides a refresh functionality. The resource is automatically disposed when the widget unmounts.

```dart
class Example extends HookWidget {
  @override
  Widget build(BuildContext context) {
    final streamResource = useResourceStream<int>(() {
      return Stream.periodic(const Duration(seconds: 1), (count) => count);
    });


    return Scaffold(
      body: Center(
        child: SignalBuilder(
          builder: (context, child) {
            return streamResource.state.when(
              ready: (data) => Text('Stream value: $data'),
              error: (error, stackTrace) => Text('Error: $error'),
              loading: () => const CircularProgressIndicator(),
            );
          },
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => streamResource.refresh(),
        child: const Icon(Icons.refresh),
      ),
    );
  }
}

```

--------------------------------

### SignalBuilder Example with Counter - Dart

Source: https://solidart.mariuti.com/flutter/signal_builder

Demonstrates the basic usage of SignalBuilder in a Flutter application. The builder function creates a Text widget that displays the current value of a Signal. The widget automatically rebuilds when the 'counter' signal's value changes.

```dart
class SampleCounter extends StatefulWidget {
  const SampleCounter({super.key});


  @override
  State<SampleCounter> createState() => _SampleCounterState();
}


class _SampleCounterState extends State<SampleCounter> {
  final counter = Signal(0);


  @override
  Widget build(BuildContext context) {
    return SignalBuilder(
      builder: (context, child) {
        return Text(counter.value.toString());
      },
    );
  }
}

```

--------------------------------

### Use List Signal in Flutter HookWidget

Source: https://solidart.mariuti.com/flutter/solidart_hooks

Shows how to create and manage a list signal using useListSignal within a HookWidget. This hook provides reactive list management, automatically rebuilding the UI when the list changes. The signal is disposed when the widget is unmounted.

```dart
class Example extends HookWidget {
  @override
  Widget build(BuildContext context) {
    final items = useListSignal<String>(['Item1', 'Item2']);
    return Scaffold(
      body: Center(
        child: SignalBuilder(
          builder: (context, child) {
            return Text('Items: ${items.value.join(', ')}');
          },
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => items.add('Item${items.value.length + 1}'),
        child: const Icon(Icons.add),
      ),
    );
  }
}
```

--------------------------------

### Use Set Signal in Flutter HookWidget

Source: https://solidart.mariuti.com/flutter/solidart_hooks

Illustrates creating and using a set signal with useSetSignal in a HookWidget. This hook enables reactive management of unique items, ensuring the UI updates upon set modifications. The signal is automatically disposed upon widget unmounting.

```dart
class Example extends HookWidget {
  @override
  Widget build(BuildContext context) {
    final uniqueItems = useSetSignal<String>({'Item1', 'Item2'});
    return Scaffold(
      body: Center(
        child: SignalBuilder(
          builder: (context, child) {
            return Text('Items: ${uniqueItems.value.join(', ')}');
          },
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => uniqueItems.add('Item${uniqueItems.value.length + 1}'),
        child: const Icon(Icons.add),
      ),
    );
  }
}
```

--------------------------------

### Transform Signal Value Type with Computed (Dart)

Source: https://solidart.mariuti.com/learning/computed

Illustrates using a Computed signal to transform the value type of an existing Signal. In this example, a boolean signal 'isGreaterThan5' is derived from an integer 'counter' signal, becoming true only when the counter exceeds 5. The example details how 'isGreaterThan5' updates its value based on the 'counter' threshold.

```dart
final counter = Signal(0); // type: int
final isGreaterThan5 = Computed(() => counter() > 5); // type: bool

// isGreaterThan5 will update only when the counter value becomes lower/greater than 5.
// If the counter value is 0, isGreaterThan5 is equal to false.
// If you update the value to 1, isGreaterThan5 doesn’t emit a new value, but still contains false.
// If you update the value to 6, isGreaterThan5 emits a new true value.
```

--------------------------------

### Create and Use Computed Signals for Arithmetic Operations (Dart)

Source: https://solidart.mariuti.com/learning/computed

Demonstrates creating a computed signal that doubles the value of another signal. It also shows how an Effect can react to changes in both the original and computed signals. The example illustrates that the computed signal updates whenever the base signal's value changes.

```dart
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
```

--------------------------------

### Use Solidart Effect in Flutter HookWidget

Source: https://solidart.mariuti.com/flutter/solidart_hooks

Demonstrates how to create a new effect using useSolidartEffect within a HookWidget. This hook allows for running side effects in response to signal changes. It requires the 'solidart' package.

```dart
class Example extends HookWidget {
  @override
  Widget build(BuildContext context) {
    final count = useSignal(0);
    useSolidartEffect(() {
      debugPrint('Effect triggered! Count: ${count.value}');
    });
    return Scaffold(
      body: Center(
        child: SignalBuilder(
          builder: (context, child) {
            return Text('Count: ${count.value}');
          },
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => count.value++,
        child: const Icon(Icons.add),
      ),
    );
  }
}
```

--------------------------------

### Effect with Automatic Disposal (Dart)

Source: https://solidart.mariuti.com/advanced/automatic_disposal

An example of an Effect that relies on automatic disposal. In this scenario, the Effect and the Signal it depends on might live forever if not explicitly managed, as the Effect is a subscriber to the Signal.

```dart
final count = Signal(0);

@override
void initState() {
  super.initState();
  Effect(() {
      print("The count is ${count.value}");
    });
}

@override
void dispose() {
  // nothing disposed manually here
  super.dispose();
}
```

--------------------------------

### Dispose Multiple Signals for Effect (Dart)

Source: https://solidart.mariuti.com/advanced/automatic_disposal

Demonstrates that an Effect tracking multiple signals will only dispose when all tracked signals are also disposed. This example shows the manual disposal of both `count` and `name` signals to allow the Effect to be cleaned up.

```dart
final count = Signal(0);
final name = Signal('Alex');

@override
void initState() {
  super.initState();
  Effect(() {
      print("The count is ${count.value} and the name is ${name.value}");
    });
}

@override
void dispose() {
  count.dispose();
  name.dispose();
  super.dispose();
}
```

--------------------------------

### Initialize and Observe MapSignal

Source: https://solidart.mariuti.com/advanced/map_signal

Demonstrates how to create a MapSignal with initial values and set up an observer to log changes. The observer receives previous and current values upon modification.

```dart
final items = MapSignal({'a': 1, 'b': 2});


items.observe((previousValue, value) {
  print("Items changed: $previousValue -> $value");
});


items.add({'c': 3}); // prints "Items changed: {'a': 1, 'b': 2} -> {'a': 1, 'b': 2, 'c': 3}"
items.remove('a'); // prints "Items changed: {'a': 1, 'b': 2, 'c': 3} -> {'b': 2, 'c': 3}"
```

--------------------------------

### Using ListSignal for Reactive Lists in Dart

Source: https://solidart.mariuti.com/advanced/list_signal

Demonstrates the usage of ListSignal in Dart for managing lists reactively. It shows how to initialize a ListSignal, observe changes to the list, and modify its elements, triggering notifications to observers.

```dart
final items = ListSignal([1, 2]);

items.observe((previousValue, value) {
  print("Items changed: $previousValue -> $value");
});

items.add(3); // prints "Items changed: [1, 2] -> [1, 2, 3]"
items[0] = 10; // prints "Items changed: [1, 2, 3] -> [10, 2, 3]"
```

--------------------------------

### Create and Initialize a Signal

Source: https://solidart.mariuti.com/learning/signal

Demonstrates how to create a new Signal with an initial value. The Signal will hold and manage this value, allowing for reactivity.

```dart
final counter = Signal(0);
```

--------------------------------

### Create a Resource from a Future (Dart)

Source: https://solidart.mariuti.com/learning/resource

Demonstrates creating a Resource from a Future function to fetch user data. It handles the async states (data, error, loading) and shows how to use it within a SignalBuilder widget.

```dart
import 'package:http/http.dart' as http;
import 'package:solidart/solidart.dart';

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

final user = Resource(fetchUser);

// Example widget usage:
/*
SignalBuilder(
  builder: (context, child) {
    return user.state.when(
      ready: (data) => Text(data),
      error: (error, stackTrace) => Text('Error: $error'),
      loading: () => const Text('Loading...'),
    );
  },
),
*/
```

--------------------------------

### Resource Switching Async Source Based on Signal (Dart)

Source: https://solidart.mariuti.com/learning/resource

Shows how a Resource can dynamically switch its asynchronous data source based on changes in another Signal. This enables reactive fetching of data, such as user details based on a user ID Signal.

```dart
import 'package:solidart/solidart.dart';

// Assume getUserData is a function that returns Future<String?>
Future<String?> getUserData(String id) async { /* ... */ return 'User data for $id'; }

final userId = Signal<String?>(null);

late final userData = Resource(
  () {
    return switch (userId.value) {
      // If userId is null, return null
      null => Future.value(null),
      // Otherwise fetch the user data
      final id => getUserData(id),
    };
  },
  // Everytime the userId changes, the resource will be triggered to fetch new data
  source: userId,
);
```

--------------------------------

### Create a Resource from a Stream (Dart)

Source: https://solidart.mariuti.com/learning/resource

Illustrates creating a Resource from a Stream. This allows managing the stream's values as they arrive, maintaining the same state handling (data, error, loading) as Future-based Resources.

```dart
import 'package:solidart/solidart.dart';

final stream = Stream.periodic(
  const Duration(seconds: 1),
  (count) => 'Tick: $count',
);

final resource = Resource.stream(() => stream);

// The widget usage is the same as for Future-based Resources.
```

--------------------------------

### Resource Stream Switching Async Source Based on Signal (Dart)

Source: https://solidart.mariuti.com/learning/resource

Demonstrates a Resource that uses a Stream as its source and can switch this stream dynamically based on a Signal's value. This is useful for scenarios where the data source itself is stream-based and needs to be reactive.

```dart
import 'package:solidart/solidart.dart';

// Assume getUserDataStream is a function that returns Stream<String?>
Stream<String?> getUserDataStream(String id) { /* ... */ return Stream.value('Stream data for $id'); }

final userId = Signal<String?>(null);

late final userData = Resource.stream(
  () {
    return switch (userId.value) {
      // If userId is null, return an empty stream
      null => Stream.value(null),
      // Otherwise fetch the user data stream
      final id => getUserDataStream(id),
    };
  },
  // Everytime the userId changes, the resource will be triggered to fetch new data
  source: userId,
);
```

--------------------------------

### Initialize and Observe SetSignal

Source: https://solidart.mariuti.com/advanced/set_signal

Demonstrates how to initialize a SetSignal with an initial set of values and observe changes to it. The observer function receives the previous and current values of the set.

```typescript
final items = SetSignal({1, 2});


items.observe((previousValue, value) => {
  print("Items changed: $previousValue -> $value");
});


items.add(3); // prints "Items changed: [1, 2] -> [1, 2, 3]"
items.remove(1); // prints "Items changed: [1, 2, 3] -> [2, 3]"
```

--------------------------------

### Batching Reactive Updates in Dart with SolidArt

Source: https://solidart.mariuti.com/learning/batch

Demonstrates how to use the `batch` function in SolidArt to group multiple signal updates. Changes within the batch are applied together, and observers are notified only after the batch completes, preventing intermediate state observations.

```dart
import 'package:solidart/solidart.dart';

void main() {
  final x = Signal(10);
  final y = Signal(20);

  Effect(() => print('x = ${x.value}, y = ${y.value}'));
  // The Effect above prints 'x = 10, y = 20'

  batch(() {
    x.value++;
    y.value++;
  });
  // The Effect above prints 'x = 11, y = 21'
}
```

--------------------------------

### Using Computed Signal as Resource Source (Dart)

Source: https://solidart.mariuti.com/learning/resource

Explains how to use a Computed Signal as the source for a Resource when the async operation depends on multiple other Signals. The Resource will re-fetch when any of the Signals contributing to the Computed value change.

```dart
import 'package:solidart/solidart.dart';

final userId = Signal<String?>(null);
final authToken = Signal<String?>(null);

final source = Computed(() => (userId.value, authToken.value));

// Example Resource using 'source':
// final userData = Resource(() => fetchUserData(source.value.$1, source.value.$2), source: source);
```

--------------------------------

### Observe Signal Changes

Source: https://solidart.mariuti.com/learning/signal

Demonstrates how to subscribe to changes in a Signal using the `observe` method. The provided callback function is executed whenever the signal's value is updated.

```dart
final counter = Signal(0);
counter.observe((previousValue, value) {
  print("Counter changed from $previousValue to $value");
});
```

--------------------------------

### Observe Signal Changes Immediately

Source: https://solidart.mariuti.com/learning/signal

Shows how to use the `observe` method with `fireImmediately: true`, causing the observer callback to execute immediately with the current signal value upon subscription.

```dart
counter.observe((previousValue, value) {
  print("Counter changed from $previousValue to $value");
}, fireImmediately: true);
```

--------------------------------

### Debouncing Resource Fetch with debounceDelay (Dart)

Source: https://solidart.mariuti.com/learning/resource

Illustrates how to apply a debounce delay to a Resource's fetch operation using the `debounceDelay` parameter. This prevents excessive calls to the async source, which is particularly useful when the source is tied to rapid user input like a text field.

```dart
import 'package:solidart/solidart.dart';

// Assume fetchSomeData is your async function
Future<String> fetchSomeData() async { /* ... */ return 'Data'; }

final debouncedResource = Resource(
  fetchSomeData,
  debounceDelay: const Duration(seconds: 1),
  // Optionally provide a source Signal that triggers the debounce
  // source: someSignal,
);
```

--------------------------------

### Conditional Rendering with Show Widget in Flutter

Source: https://solidart.mariuti.com/flutter/show

This snippet demonstrates using the Show widget for conditional rendering, which is often more readable than SignalBuilder for simple conditions. The Show widget takes a 'when' condition and 'builder' and optional 'fallback' widgets. It efficiently updates the UI when the 'when' condition changes.

```dart
class Sample extends StatefulWidget {
  const Sample({super.key});


  @override
  State<Sample> createState() => _SampleState();
}


class _SampleState extends State<Sample> {
  final loggedIn = Signal(false);


  @override
  Widget build(BuildContext context) {
    return Show(
      when: loggedIn,
      builder: (context) => const Text('Logged In'),
      fallback: (context) => const Text('Logged out'),
    );
  }
}

```

--------------------------------

### Await Signal Condition

Source: https://solidart.mariuti.com/learning/signal

Shows how to use the `until` method to asynchronously wait for a Signal's value to meet a specified condition. Includes optional timeout handling for safety.

```dart
final counter = Signal(0);
await counter.until((value) => value >= 5, timeout: Duration(seconds: 10));
```

--------------------------------

### Configure solidart_lint in analysis_options.yaml

Source: https://solidart.mariuti.com/getting-started/setup

Adds the solidart_lint plugin to your analysis_options.yaml file. This enables static analysis checks for flutter_solidart to catch common issues and simplify development.

```yaml
plugins:
  solidart_lint: ^3.0.0

```

--------------------------------

### Import solidart Package (Dart)

Source: https://solidart.mariuti.com/getting-started/setup

Imports the necessary components from the Solidart library into your Dart code. This allows you to utilize its reactive primitives and features.

```dart
import 'package:solidart/solidart.dart';
```

--------------------------------

### Create and Run a Solidart Effect

Source: https://solidart.mariuti.com/learning/effects

Demonstrates how to create an effect that prints the current value of a signal whenever it changes. The effect runs immediately upon creation and re-executes when the signal's value is updated.

```dart
final disposeEffect = Effect(() {
    print("The count is now ${counter.value}");
});

counter.value++;
```

--------------------------------

### Show Widget with Boolean Conversion in Flutter

Source: https://solidart.mariuti.com/flutter/show

This snippet illustrates how the Show widget can handle conditions that are not direct booleans by using a function that returns a boolean. It shows converting a signal's numeric value into a boolean for conditional rendering. The 'when' parameter accepts any function returning a bool.

```dart
class Sample extends StatefulWidget {
  const Sample({super.key});


  @override
  State<Sample> createState() => _SampleState();
}


class _SampleState extends State<Sample> {
  final count = Signal(0);


  @override
  Widget build(BuildContext context) {
    return Show(
      when: () => count() > 5,
      builder: (context) => const Text('Count is greater than 5'),
      fallback: (context) => const Text('Count is lower than 6'),
    );
  }
}

```

--------------------------------

### Safe Dispose Implementation (Dart)

Source: https://solidart.mariuti.com/advanced/automatic_disposal

Shows a snippet of the `dispose` method implementation, highlighting the check for `_disposed` to prevent errors if `dispose()` is called multiple times on an already disposed object. This ensures idempotency.

```dart
@override
void dispose() {
  // ignore if already disposed
  if (_disposed) return;
  ...
```

--------------------------------

### Displaying Refresh State with SignalBuilder (Dart)

Source: https://solidart.mariuti.com/learning/resource

This snippet demonstrates how to use SignalBuilder to display the 'isRefreshing' state from a Solidart Resource. It conditionally shows a CircularProgressIndicator when refreshing and an ElevatedButton to trigger a refresh otherwise. This pattern is useful for providing visual feedback to the user during background data updates.

```dart
SignalBuilder(builder: (context, child) {
  final userState = user.state;
  return userState.when(
    ready: (data) {
      return Column(
        mainAxisSize: MainAxisSize.min,
        children: [
          Text(data),
          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: () => CircularProgressIndicator(),
  );
}),
```

--------------------------------

### Import solidart_hooks Package (Flutter)

Source: https://solidart.mariuti.com/getting-started/setup

Imports the solidart_hooks package into your Flutter project. This allows you to leverage hooks for more concise state management with Solidart.

```dart
import 'package:solidart_hooks/solidart_hooks.dart';
```

--------------------------------

### Import flutter_solidart Package (Flutter)

Source: https://solidart.mariuti.com/getting-started/setup

Imports the flutter_solidart package into your Flutter project. This enables the use of Solidart's reactive features within your Flutter UI and logic.

```dart
import 'package:flutter_solidart/flutter_solidart.dart';
```

--------------------------------

### Conditional Rendering with SignalBuilder in Flutter

Source: https://solidart.mariuti.com/flutter/show

This snippet shows how to conditionally render widgets based on a signal's state using SignalBuilder. It's a common pattern for reactive UI updates in Flutter with Solidart. The builder function checks the signal's value and returns the appropriate widget.

```dart
class Sample extends StatefulWidget {
  const Sample({super.key});


  @override
  State<Sample> createState() => _SampleState();
}


class _SampleState extends State<Sample> {
  // sample signal that tells if the user is logged in or not
  final loggedIn = Signal(false);


  @override
  Widget build(BuildContext context) {
    return SignalBuilder(
      builder: (context, child) {
        if (loggedIn()) return const Text('Logged in');
        return const Text('Logged out');
      },
    );
  }
}

```

--------------------------------

### React to Multiple Signals with Effect

Source: https://solidart.mariuti.com/learning/signal

Introduces the `Effect` class for reacting to changes in multiple Signals simultaneously. The effect's callback is executed immediately and whenever any of the observed signals change.

```dart
final counter = Signal(0);
final doubleCounter = Signal(0);
Effect(() {
  print('Counter is ${counter.value}, double is ${doubleCounter.value}');
});
```

--------------------------------

### Create a Read-Only Signal

Source: https://solidart.mariuti.com/learning/signal

Explains how to create a Signal that can only be read, not modified directly. This is achieved using the `toReadSignal` method, enhancing data integrity.

```dart
final counter = Signal(0);
final readOnlyCounter = counter.toReadSignal();
print(readOnlyCounter.value); // prints 0
// The code below is invalid and will cause a compile-time error because no setter is present
readOnlyCounter.value = 2;
```

--------------------------------

### Manually Dispose Effect (Dart)

Source: https://solidart.mariuti.com/advanced/automatic_disposal

Illustrates how to manually dispose an Effect to ensure its associated signals are also disposed. This is crucial when an Effect might otherwise prevent its dependencies from being garbage collected, leading to memory leaks.

```dart
final count = Signal(0);
late final DisposeEffect disposeEffect;

@override
void initState() {
  super.initState();
  disposeEffect = Effect(() {
      print("The count is ${count.value}");
    });
}

@override
void dispose() {
  disposeEffect();
  super.dispose();
}
```

--------------------------------

### Globally Disabling 'useRefreshing' Behavior (Dart)

Source: https://solidart.mariuti.com/learning/resource

This code snippet shows how to globally disable the default 'useRefreshing' behavior in Solidart by setting `SolidartConfig.useRefreshing` to false. This ensures that all resource refreshes will transition the state to 'loading' by default. This configuration should typically be done at the application's entry point.

```dart
void main() {
  SolidartConfig.useRefreshing = false;
  runApp(const MyApp());
}
```

--------------------------------

### Access Previous Signal Value

Source: https://solidart.mariuti.com/learning/signal

Explains how to access the previous value of a Signal using the `previousValue` property and check its existence with `hasPreviousValue`. This is useful for comparing states.

```dart
final counter = Signal(0);
print(counter.hasPreviousValue); // prints false (no previous value is present)
print(counter.previousValue); // prints null (no previous value is present)
counter.value = 1;
print(counter.hasPreviousValue); // prints true (previous value is present)
print(counter.previousValue); // prints 0
```

--------------------------------

### Customize Signal Auto-Dispose (Dart)

Source: https://solidart.mariuti.com/advanced/automatic_disposal

Demonstrates how to disable automatic disposal for a specific Signal by setting `autoDispose` to `false` during its creation. This ensures the Signal persists even when it has no active subscribers.

```dart
final counter = Signal(0, autoDispose: false);
```

--------------------------------

### Update Signal Value

Source: https://solidart.mariuti.com/learning/signal

Illustrates two methods for changing a Signal's value: directly setting it and updating it based on its current value using a callback function.

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

--------------------------------

### Disable Previous Value Tracking

Source: https://solidart.mariuti.com/learning/signal

Demonstrates how to disable the tracking of previous values for a specific Signal by passing `trackPreviousValue: false` to the constructor, or globally via `SolidartConfig`.

```dart
final counter = Signal(0, trackPreviousValue: false);

// Globally
// SolidartConfig.trackPreviousValue = false;
// do it before runApp()
```

--------------------------------

### Update linter rules for Solidart

Source: https://solidart.mariuti.com/getting-started/setup

Modifies linter rules in analysis_options.yaml to optimize for Solidart usage. This includes disabling specific rules that might conflict with Solidart's patterns.

```yaml
linter:
  rules:
    use_late_for_private_fields_and_variables: false
    implicit_call_tearoffs: false
    specify_nonobvious_property_types: false

```

--------------------------------

### Disable Global Auto-Dispose (Dart)

Source: https://solidart.mariuti.com/advanced/automatic_disposal

Shows how to disable automatic disposal globally for all Solidart trackable objects by setting `SolidartConfig.autoDispose` to `false`. This affects all Signals, Computeds, Resources, and Effects unless overridden individually.

```dart
SolidartConfig.autoDispose = false;
```

--------------------------------

### Read Signal Value

Source: https://solidart.mariuti.com/learning/signal

Shows how to access the current value stored within a Signal. This is a fundamental operation for using signal data.

```dart
print(counter.value); // prints 0
```

--------------------------------

### Derive Signal from a Sub-field of a Signal (Dart)

Source: https://solidart.mariuti.com/learning/computed

Shows how to create a computed signal that specifically tracks the 'age' property of a User object held within a Signal. An Effect is used to observe changes in this derived 'age' signal, printing previous and new values. Updates to other properties of the User signal do not trigger the effect, while age updates do.

```dart
// sample User class
class User {
  const User({
    required this.name,
    required this.age,
  });

  final String name;
  final int age;

  User copyWith({
    String? name,
    int? age,
  }) {
    return User(
      name: name ?? this.name,
      age: age ?? this.age,
    );
  }
}

// create a user signal
final user = Signal(const User(name: "name", age: 20));

// create a derived signal just for the age
final age = Computed(() => user().age);

// adding an effect to print the age
Effect(() {
  print('age changed from ${age.previousValue} into ${age.value}');
});

// just update the name, the effect above doesn't run because the age has not changed
user.updateValue((value) => value.copyWith(name: 'new-name'));

// just update the age, the effect above prints
user.updateValue((value) => value.copyWith(age: 21));
```

--------------------------------

### Execute Callback Without Tracking (Dart)

Source: https://solidart.mariuti.com/learning/untracked

The `untracked` function in Solidart executes a given callback function. Any signal reads within this callback will not be tracked by the reactive system. This prevents the calling context (e.g., an Effect) from re-running when the signals read inside `untracked` change. It takes a function as an argument and returns the result of that function.

```dart
final count = Signal(0);
final doubleCount = Signal(0);


Effect(() {
  final value = count();
  untracked(() {
    doubleCount.value = value * 2;
  });
});
```

--------------------------------

### Dispose a Solidart Effect

Source: https://solidart.mariuti.com/learning/effects

Shows how to manually stop an effect from listening to signal changes. Invoking the `disposeEffect` callback returned by the `Effect` constructor prevents the effect from running again.

```dart
final disposeEffect = Effect(() {
    print("The count is now ${counter.value}");
});


// Somewhere else, dispose the effect
disposeEffect();
```
Tokens:
Raw