Nice Modal

A modal state manager for React.

ModalReact
eBay/nice-modal-reactebay.github.io/nice-modal-react@ebay/nice-modal-react

README

Nice Modal


This is a small, zero dependency utility to manage modals in a natural way for React. It uses context to persist state of modals globally so that you can show/hide a modal easily either by the modal component or id.

You can also see the introduction at eBay tech blog.

NPM Downloads Build Status Coverage Status Demo MIT licensed

For example, you can use below code to show a modal anywhere:

  1. ``` js
  2. import NiceModal from '@ebay/nice-modal-react';
  3. import MyModal from './MyModal';

  5. //...
  6. NiceModal.show(MyModal, { someProp: 'hello' }).then(() => {
  7.   // do something if the task in the modal finished.
  8. });
  9. //...
  10. ```

Or you can register the modal with an id so that you don't need to import the modal component to use it:
  1. ``` js
  2. import NiceModal from '@ebay/nice-modal-react';
  3. import MyModal from './MyModal';

  5. NiceModal.register('my-modal', MyModal);

  7. // you can use the string id to show/hide the modal anywhere
  8. NiceModal.show('my-modal', { someProp: 'hello' }).then(() => {
  9.   // do something if the task in the modal finished.
  10. });
  11. //...

  13. ```

NOTE: @ebay/nice-modal-react is not a React modal component but should be used with other modal/dialog implementions by UI libraries like Material UI, Ant.Design, Bootstrap React, etc.

Examples

You can see a list of examples at: https://ebay.github.io/nice-modal-react

Key Features

Zero dependency and small: ~2kb after gzip.
Uncontrolled. You can close modal itself in the modal component.
Decoupled. You don't have to import a modal component to use it. Modals can be managed by id.
The code of your modal component is not executed if it's invisible.
It doesn't break the transitions of showing/hiding a modal.
Promise based. Besides using props to interact with the modal from the parent component, you can do it easier by promise.
Easy to integrate with any UI library.

Motivation

Using modals in React is a bit frustrating. Think of that if you need to implement below UI:


The dialog is used to create a JIRA ticket. It could be shown from many places, from the header, to the context menu, to the list page. Traditionally, we had declared modal components with a JSX tag. But then the question became, “Where should we declare the tag?”

The most common option was to declare it wherever it was being used. But using modals in a declarative way is not only about a JSX tag, but also about maintaining the modal’s state like visibility, parameters in the container component. Declaring it everywehre means managing state everywhere. It's frustrating.

The other option put it in the Root component, for example:

  1. ``` js
  2. const Root = () => {
  3.   const [visible, setVisible] = useState(false);
  4.   // other logic ...
  5.   return (
  6.     <>
  7.       <Main />
  8.       <NewTicketModal visible={visible} />
  9.     </>
  10.   );
  11. }
  12. ```

However, when you declare the modal in the root component, there are some issues:

1. Not scalable. It's unreasonable to maintain the modal's state in the root component. When you need more modals you need to maintain much state, especially you need to maintain arguments for the modal.
2. It's hard to show or hide the modal from children components. When you maintain the state in a component then you need to pass setVisible down to the place where you need to show or hide the modal. It makes things too complicated.

Unfortunately, most examples of using modals just follow this practice, it causes such confusions when managing modals in React.

I believe you must once encountered with the scenario that originally you only needed to show a modal when click a button, then when requirements changed, you need to open the same modal from a different place. Then you have to refactor your code to re-consider where to declare the modal. The root cause of such annoying things is just because we have not understood the essential of a modal.

Rethink the Modal Usage Pattern in React

According to the wikipedia, a modal can be described as:

A window that prevents the user from interacting with your application until he closes the window.


From the definition we can get a conclusion: a modal is a global view that's not necessarily related with a specific context.

This is very similar with the page concept in a single page UI application. The visibility/ state of modals should be managed globally because, from the UI perspective, a modal could be showed above any page/component. The only difference between modal and page is: a modal allows you to not leave the current page to do some separate tasks.

For pages management, we already have router framework like React Router, it helps to navigate to a page by URL. Actually, you can think URL a global id for a page. So, similarly, what if you assign a uniq id to a modal then show/hide it by the id? This is just how we designed NiceModal.

However, besides using id, NiceModal allows to use the modal component directly to manage it.

Usage

Installation


  1. ``` sh
  2. # with yarn
  3. yarn add --dev @ebay/nice-modal-react

  5. # or with npm
  6. npm install @ebay/nice-modal-react --save-dev
  7. ```

Create Your Modal Component

With NiceModal you can create a separate modal component easily. It's just the same as you create a normal component but wrap it with high order compponent by NiceModal.create. For example, below code shows how to create a dialog with Ant.Design:

  1. ``` js
  2. import { Modal } from 'antd';
  3. import NiceModal, { useModal } from '@ebay/nice-modal-react';

  5. export default NiceModal.create(({ name }) => {
  6.   // Use a hook to manage the modal state
  7.   const modal = useModal();
  8.   return (
  9.     <Modal
  10.       title="Hello Antd"
  11.       onOk={() => modal.hide()}
  12.       visible={modal.visible}
  13.       onCancel={() => modal.hide()}
  14.       afterClose={() => modal.remove()}
  15.     >
  16.       Hello {name}!
  17.     </Modal>
  18.   );
  19. });
  20. ```

From the code, we can see:
The modal is uncontrolled. You can hide your modal inside the component regardless where it is showed.
The high order component created by NiceModal.create ensures your component is not executed before it becomes visible.
You can call modal.remove to remove your modal component from the React component tree to reserve transitions.

Next, let's see how to use the modal.

Using Your Modal Component

There are very flexible APIs for you to manage modals. See below for the introduction.

Embed your application with NiceModal.Provider:

Since we will manage status of modals globally, the first thing is embedding your app with NiceModal provider, for example:

  1. ``` js
  2. import NiceModal from '@ebay/nice-modal-react';
  3. ReactDOM.render(
  4.   <React.StrictMode>
  5.     <NiceModal.Provider>
  6.       <App />
  7.     </NiceModal.Provider>
  8.   </React.StrictMode>,
  9.   document.getElementById('root'),
  10. );
  11. ```

The provider will use React context to maintain all modals' state.

Using the modal by component

You can control a nice modal by the component itself.
  1. ``` js
  2. import NiceModal from '@ebay/nice-modal-react';
  3. import MyAntdModal from './my-antd-modal'; // created by above code

  5. function App() {
  6.   const showAntdModal = () => {
  7.     // Show a modal with arguments passed to the component as props
  8.     NiceModal.show(MyAntdModal, { name: 'Nate' })
  9.   };
  10.   return (
  11.     <div className="app">
  12.       <h1>Nice Modal Examples</h1>
  13.       <div className="demo-buttons">
  14.         <button onClick={showAntdModal}>Antd Modal</button>
  15.       </div>
  16.     </div>
  17.   );
  18. }
  19. ```

Use the modal by id

You can also control a nice modal by id:
  1. ``` js
  2. import NiceModal from '@ebay/nice-modal-react';
  3. import MyAntdModal from './my-antd-modal'; // created by above code

  5. // If use by id, need to register the modal component.
  6. // Normally you create a modals.js file in your project
  7. // and register all modals there.
  8. NiceModal.register('my-antd-modal', MyAntdModal);

  10. function App() {
  11.   const showAntdModal = () => {
  12.     // Show a modal with arguments passed to the component as props
  13.     NiceModal.show('my-antd-modal', { name: 'Nate' })
  14.   };
  15.   return (
  16.     <div className="app">
  17.       <h1>Nice Modal Examples</h1>
  18.       <div className="demo-buttons">
  19.         <button onClick={showAntdModal}>Antd Modal</button>
  20.       </div>
  21.     </div>
  22.   );
  23. }
  24. ```


Use modal with the hook

The useModal hook can not only be used inside a modal component but also any component by passing it a modal id/component:

  1. ``` js
  2. import NiceModal, { useModal } from '@ebay/nice-modal-react';
  3. import MyAntdModal from './my-antd-modal'; // created by above code

  5. NiceModal.register('my-antd-modal', MyAntdModal);
  6. //...
  7. // if use with id, need to register it first
  8. const modal = useModal('my-antd-modal');
  9. // or if with component, no need to register
  10. const modal = useModal(MyAntdModal);

  12. //...
  13. modal.show({ name: 'Nate' }); // show the modal
  14. modal.hide(); // hide the modal
  15. //...
  16. ```

Declare your modal instead of register

The nice modal component you created can be also used as a normal component by JSX, then you don't need to register it. For example:

  1. ``` js
  2. import NiceModal, { useModal } from '@ebay/nice-modal-react';
  3. import MyAntdModal from './my-antd-modal'; // created by above code

  5. function App() {
  6.   const showAntdModal = () => {
  7.     // Show a modal with arguments passed to the component as props
  8.     NiceModal.show('my-antd-modal')
  9.   };
  10.   return (
  11.     <div className="app">
  12.       <h1>Nice Modal Examples</h1>
  13.       <div className="demo-buttons">
  14.         <button onClick={showAntdModal}>Antd Modal</button>
  15.       </div>
  16.       <MyAntdModal id="my-antd-modal" name="Nate" />
  17.     </div>
  18.   );
  19. }
  20. ```

With this approach, you can get the benifits:
Inherit React context in the modal component under some component node.
Pass arguments to the modal component via props.

NOTE: if you show the component by id but the modal is not declared or registered. Nothing will happen but only a warning message in the dev console.


Using promise API

Besides using props to interact with the modal from the parent component, you can do it easier by promise. For example, we have a user list page with a add user button to show a dialog to add user. After user is added the list should refresh itself to reflect the change, then we can use below code:

  1. ``` js
  2. NiceModal.show(AddUserModal)
  3.   .then(() => {
  4.     // When call modal.resolve(payload) in the modal component
  5.     // it will resolve the promise returned by `show` method.
  6.     // fetchUsers will call the rest API and update the list
  7.     fetchUsers()
  8.   })
  9.   .catch(err=> {
  10.     // if modal.reject(new Error('something went wrong')), it will reject the promise
  11.   });
  12. ```

You can see the live example on codesandbox.

Integrating with Redux

Though not necessary, you can integrate Redux to manage state of nice modals. Then you can use Redux dev tools to track/debug state change of modals. Here is how to do it:

  1. ``` js
  2. // First combine the reducer
  3. import { createStore, applyMiddleware, compose, combineReducers } from 'redux';
  4. import { Provider, useSelector, useDispatch } from 'react-redux';
  5. import NiceModal from '@ebay/nice-modal-react';
  6. import { Button } from 'antd';
  7. import { MyAntdModal } from './MyAntdModal';
  8. import logger from 'redux-logger';

  10. const composeEnhancers = (typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__) || compose;
  11. const enhancer = composeEnhancers(applyMiddleware(logger));

  13. const store = createStore(
  14.   combineReducers({
  15.     modals: NiceModal.reducer,
  16.     // other reducers...
  17.   }),
  18.   enhancer,
  19. );

  21. // Passing Redux state to the nice modal provider
  22. const ModalsProvider = ({ children }) => {
  23.   const modals = useSelector((s) => s.modals);
  24.   const dispatch = useDispatch();
  25.   return (
  26.     <NiceModal.Provider modals={modals} dispatch={dispatch}>
  27.       {children}
  28.     </NiceModal.Provider>
  29.   );
  30. };

  32. export default function ReduxProvider({ children }) {
  33.   return (
  34.     <Provider store={store}>
  35.       <ModalsProvider>{children}</ModalsProvider>
  36.     </Provider>
  37.   );
  38. }
  39. ```

Using with any UI library

NiceModal provides  lifecyle methods to manage the state of modals. You can use modal handler returned by useModal hook to bind any modal like component to the state. Below are typical state and methods you will use:

modal.visible: the visibility of a modal.
modal.hide: will hide the modal, that is, change modal.visible to false.
modal.remove: remove the modal component from the tree so that you modal's code is not executed when it's invisible. Usually you call this method after the modal's transition.
modal.keepMounted if you don't want to remove the modal from the tree for some instances, you can decide if call modal.remove based on value of keepMounted.

Based on these properties/methods, you can easily use NiceModal with any modal-like component provided by any UI libraries.

Using help methods

As you already saw, we use code similar with below to manage the modal state:

  1. ``` js
  2. //...
  3. const modal = useModal();
  4. return (
  5.   <Modal
  6.     visible={modal.visible}
  7.     title="Hello Antd"
  8.     onOk={() => modal.hide()}
  9.     onCancel={() => modal.hide()}
  10.     afterClose={() => modal.remove()}
  11.   >
  12.     Hello NiceModal!
  13.   </Modal>
  14. );
  15. //...
  16. ```

It binds visible property to the modal handler, and use modal.hide to hide the modal when close button is clicked. And after the close transition it calls modal.remove to remove the modal from dom node.

For every modal implementation we always need to these binding manually. So, to make it easier to use we provides helper methods for 3 popular UI libraries Material UI, Ant.Design and Bootstrap React.


  1. ``` js
  2. import NiceModal, {
  3.   muiDialog,
  4.   muiDialogV5,
  5.   antdModal,
  6.   antdModalV5,
  7.   antdDrawer,
  8.   antdDrawerV5,
  9.   bootstrapDialog
  10. } from '@ebay/nice-modal-react';

  12. //...
  13. const modal = useModal();
  14. // For MUI
  15. <Dialog {...muiDialog(modal)}>

  17. // For MUI V5
  18. <Dialog {...muiDialogV5(modal)}>

  20. // For ant.design
  21. <Modal {...antdModal(modal)}>

  23. // For ant.design v4.23.0 or later
  24. <Modal {...antdModalV5(modal)}>

  26. // For antd drawer
  27. <Drawer {...antdDrawer(modal)}>

  29. // For antd drawer v4.23.0 or later
  30. <Drawer {...antdDrawerV5(modal)}>

  32. // For bootstrap dialog
  33. <Dialog {...bootstrapDialog(modal)}>

  35. ```

These helpers will bind modal's common actions to correct properties of the component. However you can always override the property after the helpers property. For example:

  1. ``` js
  2. const handleSubmit = () => {
  3.   doSubmit().then(() => {
  4.     modal.hide();
  5.   });
  6. }
  7. <Modal {...antdModal(modal)} onOk={handleSubmit}>
  8. ```

In the example, the onOk property will override the result from antdModal helper.

API Reference

https://ebay.github.io/nice-modal-react/api/

Testing


You can test your nice modals with tools like @testing-library/react.

  1. ``` js
  2. import NiceModal from '@ebay/nice-modal-react';
  3. import { render, act, screen } from '@testing-library/react';
  4. import { MyNiceModal } from '../MyNiceModal';

  6. test('My nice modal works!', () => {
  7.   render(<NiceModal.Provider />
  8.   
  9.   act(() => {
  10.     NiceModal.show(MyNiceModal);
  11.   });
  12.   
  13.   expect(screen.getByRole('dialog')).toBeVisible();
  14. });
  15. ```

Contribution Guide

  1. ``` sh
  2. # 1. Clone repo
  3. git clone https://github.com/eBay/nice-modal-react.git

  5. # 2. Install deps
  6. cd nice-modal-react
  7. yarn

  9. # 3. Make local repo as linked
  10. yarn link

  12. # 4. Start dev server
  13. yarn dev

  15. # 5. Install examples deps
  16. cd example
  17. yarn

  19. # 6. Use local linked lib
  20. yarn link @ebay/nice-modal-react

  22. # 7. Start examples dev server
  23. yarn start
  24. ```

Then you can access http://localhost:3000 to see the examples.


License

MIT