Gathering detailed insights and metrics for react-image
Gathering detailed insights and metrics for react-image
React.js <img> tag rendering with multiple fallback & loader support
npm install react-image
Typescript
Module System
Node Version
NPM Version
92.9
Supply Chain
94.4
Quality
76.2
Maintenance
100
Vulnerability
100
License
TypeScript (67.37%)
JavaScript (32.17%)
HTML (0.46%)
Love this project? Help keep it running — sponsor us today! 🚀
Total Downloads
18,892,981
Last Day
18,625
Last Week
98,455
Last Month
404,667
Last Year
4,213,609
MIT License
1,208 Stars
1,932 Commits
91 Forks
6 Watchers
10 Branches
23 Contributors
Updated on Feb 11, 2025
Minified
Minified + Gzipped
Latest Version
4.1.0
Package Id
react-image@4.1.0
Unpacked Size
39.34 kB
Size
11.07 kB
File Count
20
NPM Version
9.5.0
Node Version
18.14.2
Published on
Mar 10, 2023
Cumulative downloads
Total Downloads
Last Day
6%
18,625
Compared to previous day
Last Week
14.9%
98,455
Compared to previous week
Last Month
23.5%
404,667
Compared to previous month
Last Year
-2.7%
4,213,609
Compared to previous year
3
38
React Image is an <img>
tag replacement and hook for React.js, supporting fallback to alternate sources when loading an image fails.
React Image allows one or more images to be used as fallback images in the event that the browser couldn't load the previous image. When using the component, you can specify any React element to be used before an image is loaded (i.e. a spinner) or in the event that the specified image(s) could not be loaded. When using the hook this can be achieved by wrapping the component with <Suspense>
and specifying the fallback
prop.
React Image uses the useImage
hook internally which encapsulates all the image loading logic. This hook works with React Suspense by default and will suspend painting until the image is downloaded and decoded by the browser.
react-image
using npm:npm install react-image --save
1<script src="https://unpkg.com/react-image/umd/index.js"></script>
react-image
has no external dependencies, aside from a version of react
and react-dom
which support hooks and @babel/runtime
.
You can use the standalone component, documented below, or the useImage
hook.
The useImage
hook allows for incorporating react-image
's logic in any component. When using the hook, the component can be wrapped in <Suspense>
to keep it from rendering until the image is ready. Specify the fallback
prop to show a spinner or any other component to the user while the browser is loading. The hook will throw an error if it fails to find any images. You can wrap your component with an Error Boundary to catch this scenario and do/show something.
Example usage:
1import React, {Suspense} from 'react' 2import {useImage} from 'react-image' 3 4function MyImageComponent() { 5 const {src} = useImage({ 6 srcList: 'https://www.example.com/foo.jpg', 7 }) 8 9 return <img src={src} /> 10} 11 12export default function MyComponent() { 13 return ( 14 <Suspense> 15 <MyImageComponent /> 16 </Suspense> 17 ) 18}
useImage
API:srcList
: a string or array of strings. useImage
will try loading these one at a time and returns after the first one is successfully loaded
imgPromise
: a promise that accepts a url and returns a promise which resolves if the image is successfully loaded or rejects if the image doesn't load. You can inject an alternative implementation for advanced custom behaviour such as logging errors or dealing with servers that return an image with a 404 header
useSuspense
: boolean. By default, useImage
will tell React to suspend rendering until an image is downloaded. Suspense can be disabled by setting this to false.
returns:
src
: the resolved image addressisLoading
: the currently loading status. Note: this is never true when using Suspenseerror
: any errors ecountered, if anyWhen possible, you should use the useImage
hook. This provides for greater flexibility and provides support for React Suspense.
Include react-image
in your component:
1import {Img} from 'react-image'
and set a source for the image:
1const myComponent = () => <Img src="https://www.example.com/foo.jpg" />
will resolve to:
1<img src="https://www.example.com/foo.jpg">
If the image cannot be loaded, <img>
will not be rendered, preventing a "broken" image from showing.
When src
is specified as an array, react-image
will attempt to load all the images specified in the array, starting at the first and continuing until an image has been successfully loaded.
1const myComponent = () => ( 2 <Img 3 src={['https://www.example.com/foo.jpg', 'https://www.example.com/bar.jpg']} 4 /> 5)
If an image has previously been attempted unsuccessfully, react-image
will not retry loading it again until the page is reloaded.
1const myComponent = () => ( 2 <Img 3 src={['https://www.example.com/foo.jpg', 'https://www.example.com/bar.jpg']} 4 loader={/*any valid react element */} 5 /> 6)
If an image was previously loaded successfully (since the last time the page was loaded), the loader will not be shown and the image will be rendered immediately instead.
1const myComponent = () => ( 2 <Img 3 src={['https://www.example.com/foo.jpg', 'https://www.example.com/bar.jpg']} 4 unloader={/*any valid react element */} 5 /> 6)
The following options only apply to the <Img>
component, not to the useImage
hook. When using the hook you can inject a custom image resolver with custom behaviour as required.
By default and when supported by the browser, react-image
uses Image.decode()
to decode the image and only render it when it's fully ready to be painted. While this doesn't matter much for vector images (such as svg's) which are rendered immediately, decoding the image before painting prevents the browser from hanging or flashing while the image is decoded. If this behaviour is undesirable, it can be disabled by setting the decode
prop to false
:
1const myComponent = () => ( 2 <Img src={'https://www.example.com/foo.jpg'} decode={false} /> 3)
When loading images from another domain with a CORS policy, you may find you need to use the crossorigin
attribute. For example:
1const myComponent = () => ( 2 <Img src={'https://www.example.com/foo.jpg'} crossorigin="anonymous" /> 3)
A wrapper element container
can be used to facilitate higher level operations which are beyond the scope of this project. container
takes a single property, children
which is whatever is passed in by React Image (i.e. the final <img>
or the loaders).
For example, to animate the display of the image (and animate out the loader) a wrapper can be set:
1<Img 2 src={'https://www.example.com/foo.jpg'} 3 container={(children) => { 4 return <div className="foo">{children}</div> 5 }} 6/>
By default, the loader and unloader components will also be wrapped by the container
component. These can be set independently by passing a container via loaderContainer
or unloaderContainer
. To disable the loader or unloader from being wrapped, pass a noop to loaderContainer
or unloaderContainer
(like unloaderContainer={img => img}
).
By definition, React Image will try loading images right away. This may be undesirable in some situations, such as when the page has many images. As with any react element, rendering can be delayed until the image is actually visible in the viewport using popular libraries such as react-visibility-sensor
. Here is a quick sample (psudocode/untested!):
1import {Img} from 'react-image' 2import VisibilitySensor from 'react-visibility-sensor' 3 4const myComponent = () => 5 <VisibilitySensor> 6 <Img src='https://www.example.com/foo.jpg'> 7 </VisibilitySensor>
Note: it is not necessary to use React Image to prevent loading of images past "the fold" (i.e. not currently visible in the window). Instead just use the native HTML <img>
element and the loading="lazy"
prop. See more here.
see above
react-image
is available under the MIT License
No vulnerabilities found.
Reason
no binaries found in the repo
Reason
17 commit(s) and 0 issue activity found in the last 90 days -- score normalized to 10
Reason
no dangerous workflow patterns detected
Reason
license file detected
Details
Reason
8 existing vulnerabilities detected
Details
Reason
no SAST tool detected
Details
Reason
Found 0/30 approved changesets -- score normalized to 0
Reason
detected GitHub workflow tokens with excessive permissions
Details
Reason
dependency not pinned by hash detected -- score normalized to 0
Details
Reason
no effort to earn an OpenSSF best practices badge detected
Reason
security policy file not detected
Details
Reason
project is not fuzzed
Details
Reason
branch protection not enabled on development/release branches
Details
Score
Last Scanned on 2025-02-03
The Open Source Security Foundation is a cross-industry collaboration to improve the security of open source software (OSS). The Scorecard provides security health metrics for open source projects.
Learn More