reactive-engine

Coordinate per-engine state and data flows in React applications.

6.4k|353|Updated May 3, 2019
One-click install
npx skills add https://github.com/petyosi/react-virtuoso --skill reactive-engine
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: reactive-engine
Source: https://github.com/petyosi/react-virtuoso/tree/main/plugins/virtuoso-skills/skills/reactive-engine
Command: npx skills add https://github.com/petyosi/react-virtuoso --skill reactive-engine

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Developers building complex React applications using modular feature engines often struggle to coordinate per-engine state, data flow, routing, and persistence across many isolated components. The Reactive Engine provides a graph-based model where Cells, Streams, Triggers, and Resources form a wired network that activates lazily per engine, enabling isolated instances while sharing node definitions.

Core Features & Use Cases

  • Core Node types: Cell, Stream, Trigger, Resource, DerivedCell
  • Module-scope wiring: defers wiring to engine activation so every engine shares definitions but maintains isolated state
  • React integration: EngineProvider and hooks for reading and publishing values
  • Data fetching and routing: reactive-engine-query, reactive-engine-router, and reactive-engine-storage enable end-to-end apps
  • Cross-engine orchestration: remote hooks and per-engine lifecycle support scalable modular architectures

Quick Start

Create an Engine, define a simple Cell, publish a value, and observe the emitted state through a subscription.

Frequently Asked Questions about reactive-engine

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

FAQPage Schema
How do I coordinate state across multiple independent React feature modules?

Reactive state coordination across independent React modules is achieved using a graph-based engine that activates lazily. It maintains isolated component instances while sharing node definitions like Cells, Streams, and Resources across your application.

What is the best way to manage data fetching and routing in modular React applications?

Managing data fetching and routing in modular React applications is handled through dedicated query and router modules. These integrate with the engine to enable end-to-end reactive flows, ensuring data and routes activate only when the specific engine is engaged.

How does lazy activation work for React state management?

Lazy activation in React state management works by deferring module-scope wiring until an engine is activated. Every engine shares the same definitions but maintains completely isolated state, preventing unnecessary loads until the specific feature is engaged.

Can I use this graph engine approach for scalable cross-engine orchestration?

This graph engine approach supports scalable cross-engine orchestration through remote hooks and per-engine lifecycle management. It allows multiple independent feature engines to coordinate data flows without violating their isolated state boundaries.

Does this state management approach work with local storage in React?

This state management approach works with local storage in React through a dedicated storage module. It integrates persistence directly into the reactive graph, allowing Cells and Resources to sync with local storage across isolated engine instances.