Redus #

A Vue-like fine-grained reactivity system for Dart, designed for developer convenience and performance.

Features #

• 🎯 Fine-grained reactivity - Only update what changed
• 🚀 Lazy computed values - Cached and recomputed only when dependencies change
• ⚡ Efficient batching - Multiple changes batched into single updates
• 🧹 Automatic cleanup - Cleanup callbacks for effects
• 🎮 Full control - Stop, pause, and resume watchers
• 🔬 Effect scoping - Group and dispose effects together

Installation #

Add to your pubspec.yaml:

dependencies:
  redus: ^0.1.0

Module Structure #

The package is organized into three modules:

import 'package:redus/reactivity.dart'; // All APIs

// Or import specific modules:
// Core: ref, computed, readonly, watchEffect, watch
// Utilities: isRef, unref, toRef, toValue, toRefs, isProxy, isReactive, isReadonly
// Advanced: shallowRef, customRef, effectScope, toRaw, markRaw

Quick Start #

import 'package:redus/reactivity.dart';

void main() {
  // Create reactive values
  final count = ref(0);
  final doubled = computed(() => count.value * 2);

  // React to changes
  watchEffect((_) {
    print('Count: ${count.value}, Doubled: ${doubled.value}');
  });
  // Prints: "Count: 0, Doubled: 0"

  count.value = 5;
  // Prints: "Count: 5, Doubled: 10"
}

API Reference #

Core #

Utilities #

Advanced #

Examples #

Custom Debounced Ref #

Ref<T> useDebouncedRef<T>(T value, {Duration delay = Duration(milliseconds: 200)}) {
  Timer? timeout;
  return customRef((track, trigger) => (
    get: () {
      track();
      return value;
    },
    set: (newValue) {
      timeout?.cancel();
      timeout = Timer(delay, () {
        value = newValue;
        trigger();
      });
    },
  ));
}

Effect Scoping #

final scope = effectScope();

scope.run(() {
  final doubled = computed(() => count.value * 2);
  
  watchEffect((_) {
    print('Count: ${doubled.value}');
  });
  
  onScopeDispose(() {
    print('Scope disposed!');
  });
});

// Dispose all effects at once
scope.stop();

Shallow Ref for Large Objects #

final largeData = shallowRef(loadLargeDataset());

// Nested mutations don't trigger (performance optimization)
largeData.value['items'][0] = newItem;

// Force trigger when needed
triggerRef(largeData);

License #

MIT License - see LICENSE file for details.