Upload Image in React Typescript example (with Preview)

bezkoder React, Typescript

In this tutorial, I will show you way to Upload Image (with Preview) to a Rest API using React Typescript and Hooks. The React App uses Axios and Multipart File for making HTTP requests, Bootstrap for progress bar. You also have a display list of images’ information (with download url).

More Practice:
– React Typescript Multiple Image Upload example (with Preview)
– React Typescript CRUD example
– React Hook Form Typescript example with Validation
– React Custom Hook in Typescript example
– React Query and Axios (Typescript) example
– Spring Boot + React Typescript example

Serverless with Firebase:
– React Typescript Firebase CRUD with Realtime Database
– React Typescript Firestore CRUD example with Cloud Firestore


Overview

We’re gonna create a React Typescript Image upload with Preview example using Hooks in that user can:

  • display the preview of image before uploading
  • see the upload process (percentage) with progress bar
  • view all uploaded images
  • link to download the image when clicking on the image file name

image-upload-react-typescript-example

For multiple Images upload with preview, please visit:
React Multiple Images Upload with Preview example

react-typescript-multiple-image-upload-with-progress-bar

Technology

  • React 18/17/16
  • Axios 0.27.2
  • Bootstrap 4

Rest API for Image Upload & Storage

Here is the API that our React App will work with:

Methods Urls Actions
POST /upload upload a File
GET /files get List of Files (name & url)
GET /files/[filename] download a File

You can find how to implement the Rest APIs Server at one of following posts:
– Node Express File Upload Rest API example
– Node Express File Upload to MongoDB example
– Node Express File Upload to Google Cloud Storage example
– Spring Boot Multipart File upload (to static folder) example

Or: Spring Boot Multipart File upload (to database) example

React Typescript App for Image upload

After building the React Typescript project is done, the folder structure will look like this:

image-upload-react-typescript-project

Let me explain it briefly.

– File exports IFile interface.
– FileUploadService provides methods to save File and get Files using Axios.
– ImageUpload is a React Typescript functional component contains image upload form, image preview, progress bar, display of list of images with download url.
– App.tsx is the container that we embed all React components.

– http-common.ts initializes Axios with HTTP base Url and headers.
– We configure port for our App in .env

Setup React Typescript Image Upload Project

Open cmd at the folder you want to save Project folder, run command:
npx create-react-app react-typescript-image-upload --template typescript
Or: yarn create react-app react-typescript-image-upload --template typescript

After the process is done. We create additional folders and files like the following tree:

public
src
components
ImageUpload.tsx
services
FileUploadService.ts
types
File.ts
App.css
App.tsx
index.tsx
package.json

Import Bootstrap to React Typescript Image Upload App

Run command: npm install [email protected].
Or: yarn add [email protected]

Open src/App.tsx and modify the code inside it as following-

import "bootstrap/dist/css/bootstrap.min.css";
import "./App.css";

const App: React.FC = () => {
  return (
    ...
  );
}

export default App;

Initialize Axios for React Typescript Client

Let’s install axios with command: npm install [email protected].
Or: yarn add [email protected]

Under src folder, we create http-common.ts file with following code:

import axios from "axios";

export default axios.create({
  baseURL: "http://localhost:8080",
  headers: {
    "Content-type": "application/json",
  },
});

You can change the baseURL that depends on REST API url that your Server configures.

Create Service for File Upload

This service will use Axios to send HTTP requests.
There are 2 functions:

  • upload(file): POST form data with a callback for tracking upload progress
  • getFiles(): GET list of Files’ information

services/FileUploadService.ts

import http from "../http-common";

const upload = (file: File, onUploadProgress: any): Promise<any> => {
  let formData = new FormData();

  formData.append("file", file);

  return http.post("/upload", formData, {
    headers: {
      "Content-Type": "multipart/form-data",
    },
    onUploadProgress,
  });
};

const getFiles = () : Promise<any> => {
  return http.get("/files");
};

const FileUploadService = {
  upload,
  getFiles,
};

export default FileUploadService;

– First we import Axios as http from http-common.ts.

– Inside upload() method, we use FormData to store key-value pairs. It helps to build an object which corresponds to HTML form using append() method.

– We pass onUploadProgress to exposes progress events. This progress event are expensive (change detection for each event), so you should only use when you want to monitor it.

– We call Axios post() to send an HTTP POST for uploading a File to Rest APIs Server and get() method for HTTP GET request to retrieve all stored files.

Create File Interface

We will export a IFile type with 2 properties: url and name.

types/File.ts

export default interface IFile {
  url: string,
  name: string,
}

Create Functional Component for Upload Images

Let’s create a Image Upload UI with Progress Bar, Card, Button and Message.

First we create a React template with React Hooks (useState, useEffect) and import FileUploadService:

components/FileUpload.js

import { useState, useEffect } from "react";
import UploadService from "../services/FileUploadService";

const ImageUpload: React.FC = () => {
  
  return (
    
  );
};

export default ImageUpload;

Then we define the state using React Hooks:

...
import IFile from "../types/File";

const ImageUpload: React.FC = () => {

  const [currentImage, setCurrentImage] = useState<File>();
  const [previewImage, setPreviewImage] = useState<string>("");
  const [progress, setProgress] = useState<number>(0);
  const [message, setMessage] = useState<string>("");

  const [imageInfos, setImageInfos] = useState<Array<IFile>>([]);

  ...
}

Next we define selectImage() method which helps us to get the selected Files from <input type="file" > element later.

const ImageUpload: React.FC = () => {
  ...
  const selectImage = (event: React.ChangeEvent<HTMLInputElement>) => {
    const selectedFiles = event.target.files as FileList;
    setCurrentImage(selectedFiles?.[0]);
    setPreviewImage(URL.createObjectURL(selectedFiles?.[0]));
    setProgress(0);
  };

  ...
}

We use event.target.files[0] for accessing current Image as the first Item.

We use URL.createObjectURL() static method to get the image preview URL as previewImage. This method produces a DOMString including a URL describing the object provided in the parameter. The URL life is tied to the document in the window on which it was created.

We call UploadService.upload() method on the currentImage with a callback. So create following upload() method:

const ImageUpload: React.FC = () => {
  ...
  const upload = () => {
    setProgress(0);
    if (!currentImage) return;

    UploadService.upload(currentImage, (event: any) => {
      setProgress(Math.round((100 * event.loaded) / event.total));
    })
      .then((response) => {
        setMessage(response.data.message);
        return UploadService.getFiles();
      })
      .then((files) => {
        setImageInfos(files.data);
      })
      .catch((err) => {
        setProgress(0);

        if (err.response && err.response.data && err.response.data.message) {
          setMessage(err.response.data.message);
        } else {
          setMessage("Could not upload the Image!");
        }

        setCurrentImage(undefined);
      });
  };

  ...
}

The progress will be calculated basing on event.loaded and event.total.
If the transmission is done, we call UploadService.getFiles() to get the images’ information and assign the result to imageInfos state, which is an array of {name, url} objects.

We also need to do this work in the Effect Hook useEffect() method which serves the same purpose as componentDidMount():

const ImageUpload: React.FC = () => {
  ...
  useEffect(() => {
    UploadService.getFiles().then((response) => {
      setImageInfos(response.data);
    });
  }, []);

}

Now we return the Upload Image UI. Add the following code inside return() block:

const ImageUpload: React.FC = () => {
  ...
  return (
    <div>
      <div className="row">
        <div className="col-8">
          <label className="btn btn-default p-0">
            <input type="file" accept="image/*" onChange={selectImage} />
          </label>
        </div>

        <div className="col-4">
          <button
            className="btn btn-success btn-sm"
            disabled={!currentImage}
            onClick={upload}
          >
            Upload
          </button>
        </div>
      </div>

      {currentImage && progress > 0 && (
        <div className="progress my-3">
          <div
            className="progress-bar progress-bar-info"
            role="progressbar"
            aria-valuenow={progress}
            aria-valuemin={0}
            aria-valuemax={100}
            style={{ width: progress + "%" }}
          >
            {progress}%
          </div>
        </div>
      )}

      {previewImage && (
        <div>
          <img className="preview" src={previewImage} alt="" />
        </div>
      )}

      {message && (
        <div className="alert alert-secondary mt-3" role="alert">
          {message}
        </div>
      )}

      {imageInfos.length > 0 && (
        <div className="card mt-3">
          <div className="card-header">List of Images</div>
          <ul className="list-group list-group-flush">
            {imageInfos.map((img, index) => (
              <li className="list-group-item" key={index}>
                <p>
                  <a href={img.url}>{img.name}</a>
                </p>
                <img src={img.url} alt={img.name} height="80px" />
              </li>
            ))}
          </ul>
        </div>
      )}
    </div>
  );
};

export default ImageUpload;

We allow only image format, so the input element will have accept="image/*" attribute.

In the code above, we use Bootstrap Progress Bar:

  • .progress as a wrapper
  • inner .progress-bar to indicate the progress
  • .progress-bar requires style to set the width by percentage
  • .progress-bar also requires role and some aria attributes to make it accessible
  • label of the progress bar is the text within it

The preview of uploading image is shown: <img className="preview" src={previewImage} alt="" />

To display List of uploaded images, we iterate over imageInfos array using map() function. On each image item, we use img.url as href attribute and img.name for showing text.

Add Image Upload Page to App Component

Open App.tsx, import and embed the ImageUpload Component tag.

import React from 'react';
import "bootstrap/dist/css/bootstrap.min.css";
import './App.css';

import ImageUpload from "./components/ImageUpload";

const App: React.FC = () => {
  return (
    <div className="container" style={{ width: "600px" }}>
      <div className="my-3">
        <h3>bezkoder.com</h3>
        <h4>React Typescript Image Upload</h4>
      </div>

      <ImageUpload />
    </div>
  );
}

export default App;

App.css

.container{
  width: 500px;
}

.preview {
  max-width: 200px;
}

Configure Port for React Image Upload App

Because most of HTTP Server use CORS configuration that accepts resource sharing restricted to some sites or ports, and if you use the following Project for making Server:
– Node Express File Upload Rest API example
– Node Express File Upload to MongoDB example
– Node Express File Upload to Google Cloud Storage example
– Spring Boot Multipart File upload (to static folder) example
Or: Spring Boot Multipart File upload (to database) example

You need to configure port for our App.

In project folder, create .env file with following content:

PORT=8081

So our app will run at port 8081.

Run the App

You can find how to implement the Rest APIs Server at one of following posts:
– Node Express File Upload Rest API example
– Node Express File Upload to MongoDB example
– Node Express File Upload to Google Cloud Storage example
– Spring Boot Multipart File upload (to static folder) example
Or: Spring Boot Multipart File upload (to database) example

Run this React Typescript Image Upload App with command: npm start.
Or: yarn start

Open Browser with url http://localhost:8081/ and check the result.

Conclusion

Today we’re learned how to build a React Typescript for upload Images with Preview using React Hooks, Axios, Bootstrap with Progress Bar. We also provide the ability to show list of images, upload progress percentage, and to download Image from the server.

For Multiple Images Upload like this:

react-typescript-multiple-image-upload-with-progress-bar

Please visit:
React Typescript Multiple Images Upload with Preview example

Happy Learning! See you again.

Further Reading

– React Typescript CRUD example
– React Hook Form Typescript example with Validation
– React Custom Hook in Typescript example
– React Query and Axios (Typescript) example
– Spring Boot + React Typescript example

Serverless with Firebase:
– React Typescript Firebase CRUD with Realtime Database
– React Typescript Firestore CRUD example with Cloud Firestore

Fullstack:
– React + Spring Boot + MySQL: CRUD example
– React + Spring Boot + PostgreSQL: CRUD example
– React + Spring Boot + MongoDB: CRUD example
– React + Node + Express + MySQL: CRUD example
– React + Node + Express + PostgreSQL example
React Redux + Node + Express + MySQL: CRUD example
– React + Node + Express + MongoDB example
– React + Django + Rest Framework example

Source Code

You can find the complete source code for this tutorial at Github.

Drag-Drop instead: Drag and Drop File Upload with React Hooks example
Multiple Uploading: React Typescript Multiple Images Upload with Preview example