npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

rx-react

v0.3.0

Published

ReactJS bindings for RxJS

Downloads

13

Readme

RxReact

ReactJS bindings for RxJS

Installation

Install this module with npm:

npm install rx-react

Usage:

RxReact provides a set of utilities to work with RxJS and React :

  • The StateStreamMixin
  • The LifecycleMixin
  • The PropsMixin
  • The RxReact.Component base class
  • The FuncSubject helper

StateStreamMixin

The StateStreamMixin allows to bind a component state to an RxJS Observable stream. The way to achieve the binding is to provide a getStateStream method on your component that returns an RxJS Observable, the StateStream mixin will automatically merge the state of your component with the values published by the returned observable. The subscription will be automaticly cleaned on component unmount.

Example:

var StateStreamMixin = require('rx-react').StateStreamMixin;
var React = require('react');
var Rx = require('rx');


var Timer = React.createClass({
  mixins: [StateStreamMixin],
  getStateStream: function () {
    return Rx.Observable.interval(1000).map(function (interval) {
      return {
        secondsElapsed: interval
      };
    });
  },
  render: function () {
    var secondsElapsed = this.state ? this.state.secondsElapsed : 0;
    return (
      <div>Seconds Elapsed: {secondsElapsed}</div>
    );
  }
});

React.render(<Timer />, document.getElementById('timer-holder'));

LifecycleMixin

The LifecycleMixin allows you to consume React components lifecycle events as RxJS Observable. The LifecycleMixin will inject a property lifecycle to the component, that property contains an observable for each lifecycle events.

Example :

var LifecycleMixin = require('rx-react').LifecycleMixin;
var React = require('react');
var Rx = require('rx');


var Component = React.createClass({
  mixins: [LifecycleMixin],
  componentWillMount: function () {
    this.lifecycle.componentDidMount.subscribe(function () {
      console.log('componentDidMount');
    });
    
    this.lifecycle.componentWillReceiveProps.subscribe(function (props) {
      console.log('componentWillReceiveProps : ' JSON.stringify(props));
    });
    
    this.lifecycle.componentWillUpdate.subscribe(function ({nextProps, nextState}) {
      console.log('componentWillUpdate : ' JSON.stringify({nextProps, nextState}));
    });
    
    this.lifecycle.componentDidUpdate.subscribe(function ({prevProps, prevState}) {
      console.log('componentDidUpdate : ' JSON.stringify({prevProps, prevState}));
    });
    this.lifecycle.componentWillUnmount.subscribe(function () {
      console.log('componentWillUnmount');
    });
  },
  render: function() {
    //...
  }
});

PropsMixin

The PropsMixin allows to obtain a stream of props as RxJS Observable for your component. Example :

var PropsMixin = require('rx-react').PropsMixin;
var React = require('react');


var Component = React.createClass({
  mixins: [PropsMixin],
  componentWillMount: function () {
    this.propsStream.subscribe(function (props) {
      console.log(props.message);
    }
  },
  render: function() {
    //...
  }
});

var comp = React.render(<Component message='Hello World!' />, domNode); // log 'Hello World!'
comp.setProps({message: 'Hello John'}); // log 'Hello John'

This is particulary useful in combination with the StateStreamMixin when your component states depends on Props.

Component

The RxReact.Component is a base class combining the behavior of the PropsStreamMixin and the StateStreamMixin. It extends React.Component. Example:

var RxReact = require('rx-react');
var Rx = require('rx');

class MyComponent extends RxReact.Component {
  getStateStream() {
    return Rx.Observable.interval(1000).map(function (interval) {
      return {
        secondsElapsed: interval
      };
    });
  }
  
  render() {
    var secondsElapsed = this.state ? this.state.secondsElapsed : 0;
    return (
      <div>Seconds Elapsed: {secondsElapsed}</div>
    );
  }
}

Note that when you extend lifecycle methods, you must call the super method.

Before the 0.3.x versions RxReact.Component also implemented lifecyle mixin behavior, for some perf reasons and because most of the time it's unnecessary this has been removed. If you want reenable this behavior use FuncSubject as lifecycle method, or manually apply the LifecycleMixin on your class.

FuncSubject

The FuncSubject helper allows to create an RxJS Observable that can be injected as callback for React event handlers, refs, etc... To create an handler use the create function of FuncSubject

var myHandler = FuncSubject.create()

Example:

var FuncSubject = require('rx-react').FuncSubject;
var React = require('react');
var Rx = require('rx');


var Button = React.createClass({
  componentWillMount: function () {
    this.buttonClicked = FuncSubject.create();
    
    this.buttonClicked.subscribe(function (event) {
      alert('button clicked');
    })
  },
  render: function() {
    return <button onClick={this.buttonClicked} />
  }
});

FuncSubject also accept a function as argument, if provided this funtion will be used to map the value of each elements. This function will always be called even if the FuncSubject has no subscription.

var FuncSubject = require('rx-react').FuncSubject;
var React = require('react');
var Rx = require('rx');


var MyComponent = React.createClass({
  componentWillMount: function () {
    this.inputValue = FuncSubject.create(function (event) {
      return event.target.value
    });
    
    this.inputValue.subscribe(function (value) {
      alert('inputValue changed :' + value);
    })
  },
  render: function() {
    return <input onChange={this.inputValue} />
  }
});

FuncSubject.behavior

You can also create a FuncSubject that extends BehaviorSubject. simply use the behavior function exposed by FuncSubject:

var subject = FuncSubject.behavior(intialValue, mapFunction)

FuncSubject.async

You can also create a FuncSubject that extends AsyncSubject. simply use the async function exposed by FuncSubject:

var subject = FuncSubject.async(mapFunction)

FuncSubject.replay

You can also create a FuncSubject that extends ReplaySubject. simply use the replay function exposed by FuncSubject:

var subject = FuncSubject.replay(bufferSize, mapFunction)

FuncSubject.replay

You can create a FuncSubject from any subject base class using the factory function expsed by FuncSubject:

var subject = FuncSubject.factory(SubjectClass, mapFunction, ...constructorArgs);