signals-preact-dart

Define signal dependency tracking and update semantics for Dart's preact_signals library.

803|85|Updated Nov 18, 2023
One-click install
npx skills add https://github.com/rodydavis/signals.dart --skill signals-preact-dart
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: signals-preact-dart
Source: https://github.com/rodydavis/signals.dart/tree/main/skills/signals-preact-dart
Command: npx skills add https://github.com/rodydavis/signals.dart --skill signals-preact-dart

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

It helps you design and modify low-level preact_signals primitives in Dart safely and efficiently so reactive dependency tracking stays correct and avoids re-entrancy, cycles, and leaks.

Core Features & Use Cases

  • Core primitive definitions: Clarifies how signal, computed, effect, readonly, batch, and untracked should behave and interact.
  • Dependency tracking rules: Specifies dynamic dependency tracking semantics for effects and computations, including when reads subscribe versus do not.
  • Safety and performance guardrails: Enforces purity expectations, cycle detection avoidance patterns, lazy initialization awareness, and transactional batching behavior.

Quick Start

Ask an AI to generate or review a preact_signals Dart core change and validate it against the dependency tracking, re-entrancy, cycle, and memoization rules in this skill.

Frequently Asked Questions about signals-preact-dart

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement safe dependency tracking for reactive signals in Dart?

Safe dependency tracking in Dart signals requires dynamic subscription management during reads, ensuring effects and computed values only subscribe to dependencies actually accessed. Lazy evaluation and memoization prevent unnecessary recomputations.

How does batching work with preact signals in Dart?

Batching in Dart preact signals groups multiple signal updates into a single transactional propagation, preventing intermediate recomputations. It ensures synchronous reactivity contexts only trigger effects after the batch completes.

How do I prevent memory leaks and cycles in Dart reactive primitives?

Preventing memory leaks and cycles in Dart reactive primitives requires strict re-entrancy safety guards, proper cleanup of effect subscriptions, and dynamic dependency updates that remove stale references during signal propagation.

Can I use untracked reads to access signal values without subscribing in Dart?

Untracked reads in Dart signals allow you to access current signal values without creating dependency subscriptions. This is essential for reading state inside effects or computed values without triggering reactivity loops.

What are the rules for lazy evaluation and memoization in Dart computed signals?

Lazy evaluation in Dart computed signals defers calculation until the value is read, while memoization caches the result until dependencies change. This ensures purity expectations and avoids redundant recomputations in synchronous contexts.