Reward HN: React scream management you already know the device you would use

React scream management you already know the device you would use

• 🙂 Easy to utilize outside of react
• 🥳 Easy to utilize inner of react – fall in replacement for useState
• 😎 Look forward to scream with guarantees
• 💪 Very performant
• 🤓 Native typescript toughen
• 🥰 Petite bundle size (~1KB minified)

npm install place-react-scream

import React from 'react';
import { createState } from 'place-react-scream';

// Gain the scream with an preliminary place
const counterState = createState(0)

honest Counter() {
    // Exhaust this hook in any factor that desires to react to the scream
    const [count, setCount] = counterState.useState();
    return (
        div>
            p>{count}/p>
            button onClick={() => setCount(count + 1)}>+/button>
        /div>
    );
}

Codesandbox demo

Install

npm install place-react-scream

Or if you’re a memoir bro

memoir add place-react-scream

Gain scream

The preliminary place could well be anything: number, string, object… and heaps others.

const counterState = createState(0)

Learn scream with out a hook

Incessantly returns the novel scream place. Could perhaps well perhaps also be historical inner or outside of react elements.

console.log(counterState.place)

Write scream with out a hook

Mutate the scream inner or outside of react elements

counterState.discipline(counterState.place + 1)

Subscribe to scream with out a hook

Subscribe to scream inner or outside of react elements

const unsubscribe = counterState.subscribe(x => {
    console.log('counterState changed', x)
})

Look forward to scream with guarantees

Wait till scream is fascinating with a promise.

// Resolves when count goes above 5. 
// If the count is already above 5 it will probably perhaps resolve straight.
const highCount = stay up for counterState.waitFor(x => x > 5 ? x : untrue)

Cloak the promise will resolve if anything rather then untrue, undefined or null is returned.

Hook utilization

const [count, setCount] = counterState.useState()

Hook utilization, with a personalized selector honest

const customers = createState({
    alice: { identify: 'Alice', age: 20 },
    bob: { identify: 'Bob', age: 30 },
    chad: { identify: 'Chad', age: 40 },
});

...
// Element most efficient re-renders if alice adjustments
const [alice] = customers.useState(x => x.alice)
...

Hook utilization, with a dynamic selector honest

By default the selector honest is cached. In some rarer cases the honest could well be dynamic.
Let’s order:

const customers = createState({
    alice: { identify: 'Alice', age: 20 },
    bob: { identify: 'Bob', age: 30 },
    chad: { identify: 'Chad', age: 40 },
});


honest Foo() {
    const [name, setName] = useState('alice')
    // Add identify as a dependency to the selector
    const [user] = customers.useState(x => x[name], [name]);
    return (
        div>
            p>{person.identify} {person.age}/p>
            button onClick={() => setName('alice')}>Alice/button>
            button onClick={() => setName('bob')}>Bob/button>
            button onClick={() => setName('chad')}>Chad/button>
        /div>
    );
}

How does this compare to Zustand?

TL;DR place-react-scream is easier to utilize in undeniable javascript outside of the zustand retailer.

• Zustand has quite an odd API to learn or alter scream outside of react. Or now not it’s most distinguished to call suggestions on a hook honest?? ie useStore.getState() and useStore.setState(). With place-react-scream you would factual create retailer.place and retailer.discipline() respectively.
• Gain-react-scream has no belief of actions cherish in zustand. With place-react-scream, you factual place capabilities which might learn and write the observable scream.
• Zustand lends itself to a megastore with several substores cherish redux. Gain-react-scream lends itself to little bits of observable scream.
• Zustand would not provide a retailer.waitFor() honest which for my portion is quite an improbable design of solving flee stipulations.
• By default place-react-scream memoizes selector capabilities which implies much less code is being executed on each and every render when put next to zustand. In a gigantic app this could just well accept a gigantic performance affect.

How does this compare to ReactContext?

As a rule of thumb ReactContext could well just peaceable be historical for dependency injection now not for scream management. Though or now not it’s in overall u