Meet the new use-between.

[betula]

Hello everyone! Meet the new use-between😇

1. Totally Legal. There are no blocks from React because only the official React API is used.

2. Full support for all available React hooks. Now literally any hook can be used in use-between-new. There is also full support for hooks using context (such as hooks from react-router-dom).

It's still a long way to reach perfection, but we already have the second step on the path of evolution and the joint story that we create together.

I want to give a special thanks to @shsr04 for his contribution to the development of use-between in the form of a commit; he inspired me, and I wrote a very cool version of the new use-between.

Use it, guys, for the public good and bring issues, I'd be happy to fix them☺️

And one more thing, please give your opinion on the new version's main page. It seems to lack a certain liveliness, but I can't quite comprehend and articulate this feeling.

Enjoy and Happy Coding😇🍀

[betula]

use-between-new

An easy-to-use React hook library for sharing state between components

Imagine you have a large office with many rooms (React components), and in each room people work with their own data. Normally in React, each "room" lives its own life, and if you need to pass information from one room to another, you have to run "wires" through all the walls (prop drilling) or use complex systems like Redux.

This code solves this problem in an elegant way! 🎯

How does it work?

The code creates something like a "magic radio" for your React application. Each shared hook acts like a radio station. It can broadcast changes, and anyone can tune into its frequency.

1. The between() function — this is the main magic! You give it a regular React hook, and it transforms it into a "shared hook" that different components can connect to simultaneously. They will all see the same data in real-time.

2. Context — this is the "coverage area" of your magic radio. Inside this zone, all components can use the shared hooks.

Why is this needed?

Instead of passing data through dozens of components or setting up heavyweight state management systems, you simply wrap your hook in between() — and voilà! Any component can use this hook and receive up-to-date data automatically.

Real-life example: if one user changes the theme, all open application windows instantly switch — no manual synchronization needed! ✨

Here's how you could implement this with between():

import { useState } from "react";
import { between, Context } from "use-between-new";

// Using regular React hooks
const useSharedTheme = between(() => {
  const [theme, setTheme] = useState('light');

  return { 
    theme, 
    setTheme
  };
});

// Now use it in any component!
function Header() {
  const { theme, setTheme } = useSharedTheme();
  
  return (
    <header className={theme}>
      <button onClick={() => setTheme(theme === 'light' ? 'dark' : 'light')}>
        Toggle Theme
      </button>
    </header>
  );
}

function Sidebar() {
  const { theme } = useSharedTheme();

  return <aside className={theme}>Sidebar content</aside>;
}

// Wrap your app with Context
function App() {
  return (
    <Context>
      <Header />
      <Sidebar />
      <Footer />
    </Context>
  );
}

When you click the button in Header, both Sidebar and Footer instantly update to the new theme — no props passed, no context provider boilerplate, no Redux store. Just simple, shared state! 🎨

The code uses memoization and optimizations so components only re-render when the data actually changes.

Supported hooks

All hooks including useContext and react-router-dom.

Installation

npm install use-between-new

Features

• ✅ TypeScript support
• ✅ Minimal bundle size
• ✅ React hooks compatibility
• ✅ Automatic state synchronization
• ✅ Memory efficient

Enjoy your code!

And good luck! 🍀

[shsr04]

Good job, I read the new code, and I think it's very pretty and elegant. There is some magic in there that I don't fully understand, but certainly less than in the hacked version 😎
For the README, maybe it would be interesting to see a comparison of use-between with other state manegement libraries: use-between vs. basic useReducer vs. Redux vs. Zustand ... -> the main point is that use-between shares not only state between sibling components, but also effects and any kind of hooks. Truly mind-blowing once you realize the potential of this idea.

[melloware]

hmmm couldn't you just deprecate the old one instead of creating a new use-between-new ?

[betula]

Hi, @melloware
Nice to hear from you!

It would be awesome if the new one were better in every way, but the new use-between-new has a completely different architecture. Yes, it supports all hooks out of the box and will support all new versions of React right away. However, it has lost its glitch-free status.

Moreover, it currently lacks certain APIs found in the original use-between related to writing unit tests. This is a minor issue, but it nevertheless needs refinement.

Additionally, it requires explicit context setting for use-between, specifically with a that needs to be placed wherever the entire context will reside, and all useContext calls will draw context from there.

Moreover, all hooks must now be encapsulated in between at the code execution level, meaning we can no longer simply call useBetween anywhere and have it work as it did before.

In summary, it has become a bit more complex, which I don’t particularly like. It seems to have lost the values I wanted to share with the world. I aimed to help people write service architecture for applications in a simple and elegant manner, enabling them to focus solely on the logic they describe without realizing they are crafting a beautiful service architecture. A super low entry threshold and utmost simplicity—this is what's being lost with use-between-new.

And most importantly, it hasn't gone through years of production. It needs attention, articles written about it, product integration, and bug report collection, all of which are lengthy processes. If it gathers at least 1,000 downloads per week and receives positive user feedback, only then will it be a worthy candidate to replace use-between. For now, it's still quite "young."

[melloware]

understood. You rock @betula