React Singleton Hook
Manage global state of your React app using hooks.
Installation
To use React Singleton Hook with your React app, install it as a dependency:
npm install react-singleton-hook
yarn add react-singleton-hook
This assumes that you’re using npm package manager
with a module bundler like Webpack or
Browserify to consume CommonJS
modules.
What is a singleton hook
-
Singleton hooks very similar to React Context in terms of functionality. Each singleton hook has s body,
you might think of it as of Context Provider body. Hook has a return value, it's similar to the value provided by context.
Using a singleton hook from a component is like consuming a context.
-
Singleton hooks are lazy. the body is not executed until the hook is called by some component or other hook.
Once loaded, the hook body remains loaded forever.
If you want to eager-load some Singleton hooks, use them at the top-level component of your App.
-
Singleton hooks do not require a provider or a special App structure.
Under the hood, it uses useState/useRef/useEffect and some less-known react features for performance and portability.
-
It's possible to mix into single app Singleton hooks, React-Redux hooks api, React Context hooks and any custom hook.
Examples
convert any custom hook into singleton hook
In the code below, the user profile is not fetched until useUserProfile
used by some component,
and once fetched it is never reloaded again, the hook remains mounted forever into hidden component.
import { useEffect, useState } from 'react';
import { singletonHook } from 'react-singleton-hook';
const api = { async getMe() { return { name: 'test' }; } };
const init = { loading: true };
const useUserProfileImpl = () => {
const [profile, setProfile] = useState(init);
useEffect(() => {
api.getMe()
.then(profile => setProfile({ profile }))
.catch(error => setProfile({ error }));
}, []);
return profile;
};
export const useUserProfile = singletonHook(init, useUserProfileImpl);
dark/light mode switch
Whenever Configurator
changes darkMode, all subscribed components are updated.
import { useState } from 'react';
import { singletonHook } from 'react-singleton-hook';
const initDarkMode = false;
let globalSetMode = () => { throw new Error('you must useDarkMode before setting its state'); };
export const useDarkMode = singletonHook(initDarkMode, () => {
const [mode, setMode] = useState(initDarkMode);
globalSetMode = setMode;
return mode;
});
export const setDarkMode = mode => globalSetMode(mode);
import React from 'react';
import { useDarkMode, setDarkMode } from 'src/services/darkMode';
const Consumer1 = () => {
const mode = useDarkMode();
return <div className={`is-dark-${mode}`}>Consumer1 - {`${mode}`}</div>;
};
const Consumer2 = () => {
const mode = useDarkMode();
return <div className={`is-dark-${mode}`}>Consumer2 - {`${mode}`}</div>;
};
const Configurator = () => {
const mode = useDarkMode();
return <button onClick={() => setDarkMode(!mode)}>Toggle dark/light</button>;
};
imperatively read hook state for non-react code
import { useState } from 'react';
import { singletonHook } from 'react-singleton-hook';
const initDarkMode = false;
let currentMode = initDarkMode;
let globalSetMode = () => { throw new Error(`you must useDarkMode before setting its state`); };
export const useDarkMode = singletonHook(initDarkMode, () => {
const [mode, setMode] = useState(initDarkMode);
globalSetMode = setMode;
currentMode = mode;
return mode;
});
export const setDarkMode = mode => globalSetMode(mode);
export const getDarkMode = () => currentMode;
use react-redux (or any other context) inside singletonHook
To use react-redux or any other context-based functionality, singleton hooks should be mounted under provider in your app.
To do that, import SingletonHooksContainer
from react-singleton-hook
and mount anywhere in you app.
SingletonHooksContainer must be rendered ealier then any component using singleton hook!
By default you are not required to dial with a SingletonHooksContainer
, we run this component internally in separate react app.
import { singletonHook } from 'react-singleton-hook';
import { useSelector } from 'react-redux';
const init = { loading: true };
const useCurrentUserImpl = () => {
const session = useSelector(state => state.session);
if (session.loading) return init;
return session.user;
};
export const useCurrentUser = singletonHook(init, useCurrentUserImpl);
import React from 'react';
import ReactDOM from 'react-dom';
import { SingletonHooksContainer } from 'react-singleton-hook';
import { Provider } from 'react-redux';
import store from 'src/store';
import App from 'src/views';
const app = (
<Provider store={store}>
<>
<SingletonHooksContainer/>
<App/>
</>
</Provider>
);
ReactDOM.render(app, document.getElementById('root'));
top-level components updated before low-level components
import { useEffect, useState } from 'react';
import { singletonHook } from 'react-singleton-hook';
const initState = { loading: true };
let setSessionGlobal = () => { throw new Error('you must useSession before login'); };
const useSessionImpl = () => {
const [session, setSession] = useState(initState);
setSessionGlobal = setSession;
useEffect(() => { setSession({ loggedIn: false }); }, []);
return session;
};
export const useSession = singletonHook(initState, useSessionImpl);
export const login = (name, pass) => {
setSessionGlobal({ loggedIn: true, user: { name: 'test' } });
};
import React, { useEffect } from 'react';
import ReactDOM from 'react-dom';
import { login, useSession } from 'src/services/session';
const LoggedInView = () => {
const session = useSession();
console.log(`LoggerInView rendered with ${JSON.stringify(session)}`);
return null;
};
const LoggedOutView = () => {
const session = useSession();
console.log(`LoggedOutView rendered with ${JSON.stringify(session)}`);
return null;
};
const WaitingForSessionView = () => {
const session = useSession();
console.log(`WaitingForSessionView rendered with ${JSON.stringify(session)}`);
return null;
};
const MainComponent = () => {
const session = useSession();
useEffect(() => {
setTimeout(() => { login('testuser'); }, 2000);
}, []);
console.log(`MainComponent rendered with ${JSON.stringify(session)}`);
if (session.loading) return <WaitingForSessionView/>;
if (session.loggedIn) return <LoggedInView/>;
return <LoggedOutView/>;
};
ReactDOM.render(<MainComponent/>, document.getElementById('root'));
Initial state callback
As of version 3.0, singletonHook
accepts a callback that calculates initial state instead of predefined initial state.
This callback is called once and only when the value is required.
You can use it to calculate expensive initial values or
avoid an extra render (and a state flickering)
when initial state changes before any component consumes the hook:
example: subscribe components to pre-existing get/set data module
import { useState } from 'react';
import { singletonHook } from 'react-singleton-hook';
let isDarkMode = false;
let updateSubscribers = (mode) => {};
export const getDarkMode = () => isDarkMode;
export const setDarkMode = (newMode) => {
isDarkMode = newMode;
updateSubscribers(isDarkMode);
};
export const useDarkMode = singletonHook(getDarkMode, () => {
const [mode, setMode] = useState(getDarkMode);
updateSubscribers = setMode;
return mode;
});
setDarkMode(true);
setInterval(() => setDarkMode(!getDarkMode()), 2000);
const App = () => {
const mode = useDarkMode();
return <div className={`is-dark-${mode}`}>App - {`${mode}`}</div>;
};
React Native
To use this library with react-native you always have to mount SingletonHooksContainer
manually.
See how to do it in example: use react-redux (or any other context) inside singletonHook
Server Side Rendering
Singleton hooks are ignored during SSR and always return initial value.