Creating a Gantt chart with React using Next.js

A Gantt chart is a project management tool for coordinating complex schedules for large or multiple teams. Using a Gantt chart that is JavaScript-based has a couple of advantages over spreadsheet-based Gantt charts, such as:

• Easy integration into existing project management dashboards.
• Sharing your chart online.
• Customizing your chart to suit your needs.

In a previous article, we described how to make a basic drag-and-drop Gantt chart component using vanilla JavaScript. In this article, we'll make the same basic Gantt chart with React using Next.js.

We'll also create a basic Gantt chart using our commercial Bryntum Gantt Chart and look at the differences between building your own chart versus using an off-the-shelf solution.

The basic React Gantt chart that we'll create using Next.js will have the following features:

• The user can select the planning time period by selecting a start date and an end date.
• We’ll be able to add, delete, and edit tasks.
• Task durations can be added and deleted, and we’ll be able to edit them using drag and drop.

Once you’re done, you’ll have a Gantt chart that looks like the one shown below.

You can find the code for the completed Next.js Gantt Chart in our GitHub repository.

Getting started

We'll start this project by cloning the following Next.js Gantt chart starter GitHub repository.

The .vscode folder includes some VS Code settings and extension recommendations, as well as settings for ESLint and Prettier. ESLint and Prettier have been added and configured to format your code on paste and on save. If you don't use VS Code as an IDE, you'll need to configure these for your IDE. Once you've done that, you can delete this file.

The starter repository contains all the components you'll need to create the Gantt chart. You'll need to create some state and complete the code for the components. The code used is similar to our previous article that explains how to make a vanilla JavaScript Gantt Chart.

If you install dependencies npm install and run the local development server using npm run dev, you'll see a page with the header "Gantt Tracker".

Let's take a look at how the Gantt chart starter code is structured.

Adding styling with CSS

The CSS we'll use for the Gantt chart is included in the starter code. We've used Styled JSX, which comes with Next.js, to write scoped-styled components. There are some global styles in styles/globals.js. These global styles are added to our app in the Layout component in the components folder. The entire app is wrapped in this Layout component in the _app.js file, which is in the pages folder.

The <style jsx> tags in the components contain CSS that is scoped to the component. Styled JSX does this by making the class names unique. In the GanttChart component, there are some CSS variables for color, border radius, and cell height, which we'll use for the Gantt chart.

Utility functions, helpers, constants, and data

The fetchWrapper.js file in the utils folder contains a fetch API wrapper function that we'll use to make HTTP requests to our API endpoint. This wrapper function is from Kent C. Dodd's article Replace Axios with a simple custom fetch wrapper. We'll use this fetch wrapper function to fetch the example Gantt chart data, which is in the data.json file in the public folder.

The dateFunctions.js file in the helpers folder contains helper functions that we'll use for date calculations and formatting. Finally, the constants.js file in the root folder contains a months array that we'll use for creating the columns of the Gantt chart and for populating the select input elements for selecting the date range of our Gantt chart.

Now let's start creating the Gantt chart component.

Adding state

First, we'll add state to the GanttChart component. We'll add state for the tasks, task durations, and the time range that will show on the Gantt chart. We'll use blue horizontal bars across the cells to show task durations.

Import the useState and useEffect hooks in GanttChart.js:

import { useState, useEffect } from 'react';

Add the following state variables and setters to the GanttChart() function:

  const [tasks, setTasks] = useState(null);
  const [taskDurations, setTaskDurations] = useState(null);
  const [timeRange, setTimeRange] = useState({
    fromSelectMonth: 0,
    fromSelectYear: '2022',
    toSelectMonth: 1,
    toSelectYear: '2022',
  });

We'll get the tasks and taskDurations data from the data.json file by making a fetch request using the client fetch wrapper. Import the client function:

import { client } from '../../utils/fetchWrapper';

Add the following useEffect hook to fetch the data:

  useEffect(() => {
    client('data.json').then(
      (data) => {
        setTasks(data?.tasks);
        setTaskDurations(data?.taskDurations);
      },
      (error) => {
        console.error('Error: ', error);
      }
    );
  }, []);

After the data is fetched, the tasks and taskDurations state will be set. You'll be able to see the state in the React Developer Tools "Components" tab.

Creating the Gantt chart component

The Gantt chart component will be composed of seven components, which you'll find in the components/GanttChart folder. In the Home page file index.js, located in the pages folder, we'll import the main file GanttChart.js. There is also an AddButton component that is used in the AddTask and AddTaskDuration components.

Import the seven components in GanttChart.js:

import AddTaskDuration from './AddTaskDuration';
import AddTask from './AddTask';
import Grid from './Grid';
import Settings from './Settings';
import Tasks from './Tasks';
import TimeRange from './TimeRange';
import TimeTable from './TimeTable';

Now add them in the <div> with an id of gantt-container:

  <Grid>
    <Tasks
      tasks={tasks}
      setTasks={setTasks}
      setTaskDurations={setTaskDurations}
    />
    <TimeTable
      timeRange={timeRange}
      tasks={tasks}
      taskDurations={taskDurations}
      setTaskDurations={setTaskDurations}
    />
  </Grid>
  <Settings>
    <AddTask setTasks={setTasks} />
    <AddTaskDuration tasks={tasks} setTaskDurations={setTaskDurations} />
    <TimeRange timeRange={timeRange} setTimeRange={setTimeRange} />
  </Settings>

The Grid and Settings components are wrappers that apply some CSS styles to their children. For each of the components, destructure the passed-in props. For example, in the Tasks component, destructure tasks, setTasks, and setTaskDurations as follows:

export default function Tasks({ tasks, setTasks, setTaskDurations }) {
   // ...
}

As well as in the TimeTable component:

export default function TimeTable({
  timeRange,
  tasks,
  taskDurations,
  setTaskDurations,
}) {
    //..
}

Do the same for the AddTask, AddTaskDuration, and TimeRange components.

If you run your local server now, you should see the following basic skeleton of our app in your browser window:

Creating task rows

The Tasks component currently renders three empty div rows. Below the last <div className="gantt-task-row"></div> line, add the following code to create our task inputs:

  {tasks &&
    tasks.map((tsk, i) => (
      <div key={`${i}-${tsk?.id}-${tsk.name}`} className="gantt-task-row">
        <input data-task-id={tsk?.id} value={tsk?.name} />
        <button type="button" data-task-id={tsk?.id}>
          x
        </button>
      </div>
    ))}

We first check if tasks is not null, because Next.js does server-side rendering. The tasks state is added after the component is mounted.

We create an <input> element for each task with a value equal to the task name. There is a delete button for deleting the element. We'll use the data attributes to update the tasks state when a task is edited or deleted.

Making tasks deletable

Now let’s make the delete buttons work. First, add the following property to the delete button:

onClick={handleDelete}

Now add the following handleDelete function:

  function handleDelete(e) {
    const idNum = parseInt(e.target.getAttribute('data-task-id'));
    const newTasks = tasks.filter((task) => task.id !== idNum);
    // update state (if data on backend - make API request to update data)
    setTasks(newTasks);

    setTaskDurations((prevState) => {
      // delete any taskDurations associated with the task
      const newTaskDurations = prevState.filter(
        (taskDuration) => taskDuration.task !== idNum
      );
      return newTaskDurations;
    });
  }

We pass in a function to setTaskDurations to get the previous value of the state from the function's argument. We get the task id from the data attribute on the button. We then update the tasks state by filtering out the task by id from the tasks state passed in as a prop and then setting the tasks state using setTasks. We also update the tasksDurations state by removing any task durations associated with the deleted task and then updating the state. This causes the Tasks component to re-render, which passes in the new state.

Now if you click on the delete button, the task will be deleted.

Making tasks editable

The task inputs are not editable, let's fix that. Add the following onChange property to the task <input>:

onChange={(e) => onChange(e, i)}

Now add the following onChange function:

  function onChange(e, i) {
    const { value } = e.target;
    const idNum = parseInt(e.target.getAttribute('data-task-id'));

    let newTasks = tasks.filter((task) => task.id !== idNum);
    newTasks.push({ id: idNum, name: value });
    newTasks = newTasks.sort((a, b) => a.id - b.id);
    // update state (if data on backend - make API request to update data)
    setTasks(newTasks);
  }

We get the value of the input, and id for the task. We then create a new tasks state by filtering out the edited task, creating a new task object and then updating the tasks state. We also sort the tasks by id, the order in which they are created. When we add new tasks later in this tutorial, we'll see that the given id is a number: the most recently created tasks have a higher number.

Now try editing the tasks in your development server. You'll notice that the input loses focus after you add or remove a character from it. The tasks state is updated, as you can see in your React development tools. The input loses focus because the Tasks component is re-rendered each time the tasks state updates.

We'll fix this using two refs that will allow us to focus the correct input on each re-render. Add the following ref objects:

  const inputRef = useRef([]);
  const indexRef = useRef(null);

The inputRef will contain an array of our input elements. The indexRef will hold the index of the last input that has been changed. The ref values will persist after each re-render.

Add the following ref property to the task <input>:

ref={(el) => (inputRef.current[i] = el)}

This will set the current value of the inputRef. The array will contain a ref to each input element.

In the onChange function, add the following line:

indexRef.current = i;

This will set the indexRef to the index of the last edited input.

Now we can use these two refs to focus the input that a user is editing. Add the following useEffect hook to the Tasks component:

  useEffect(() => {
    if (inputRef.current.length && indexRef.current >= 0) {
      inputRef?.current[indexRef.current]?.focus();
    }
  });

This useEffect will run on each render. It will set focus on the input that was last edited. Now try editing the tasks in your development server. The input will maintain focus as you are editing the task.

Creating the Gantt chart grid

We'll create the Gant chart grid in the TimeTable component. At the top of the TimeTable.js file, there are some objects, including ganttTimePeriod, that we'll use for dynamic CSS styling. We'll create the grid using similar code to the previous article, which used vanilla JavaScript. We'll create the grid row by row. We'll add the task duration bars to the correct starting cell by checking the task duration's task property and its start date.

There is some starter code for creating the rows. We'll fill the monthRows, dayRows, and weekRows arrays with React elements for the Gantt chart grid and then render them.

Replace the imported modules with the following modules:

import { useState } from 'react';
import { monthDiff, getDaysInMonth, getDayOfWeek } from '../../helpers/dateFunctions';
import { months } from '../../constants';

Above the component's return, add the following for loop:

  for (let i = 0; i < numMonths; i++) {
    // create month rows
    monthRows.push(
      <div key={i} style={{ ...ganttTimePeriod, outline: 'none' }}>
        <span style={ganttTimePeriodSpan}>
          {months[month.getMonth()] + ' ' + month.getFullYear()}
        </span>
      </div>
    );

    // create day and week rows
    const numDays = getDaysInMonth(month.getFullYear(), month.getMonth() + 1);
    const currYear = month.getFullYear();
    const currMonth = month.getMonth() + 1;

    for (let j = 1; j <= numDays; j++) {
      dayRow.push(
        <div key={j} style={{ ...ganttTimePeriod, outline: 'none' }}>
          <span style={ganttTimePeriodSpan}>{j}</span>
        </div>
      );

      weekRow.push(
        <div key={j} style={{ ...ganttTimePeriod, outline: 'none' }}>
          <span style={{ ...ganttTimePeriodSpan, color: '#3E455B' }}>
            {getDayOfWeek(currYear, currMonth - 1, j - 1)}
          </span>
        </div>
      );
    }

    dayRows.push(
      <div key={i} style={{ ...ganttTimePeriod, outline: 'none' }}>
        {dayRow}
      </div>
    );

    weekRows.push(
      <div key={i} style={{ ...ganttTimePeriod, outline: 'none' }}>
        {weekRow}
      </div>
    );

    dayRow = [];
    weekRow = [];
    month.setMonth(month.getMonth() + 1);
  }

This loops through the number of months in the time period range and creates month, week, and day rows. The value for numMonths is two. We will be able to change this value when we complete the TimeRange component’s code later in the tutorial. We use the month variable and the setMonth method to increment the month value on each loop. We use this value and the months array from our constants file to add styled React elements with the correct month name to the monthRows array.

We use a nested loop to create the dayRow and weekRow cells. We make use of JavaScript Date methods, as well as the getDaysInMonth and getDayOfWeek functions from our dateFunctions file.

If you view your app now, you'll see the year and month, day of the month, and day of the week rows. They'll be positioned correctly once we add the date cells for each task.

Now let's create the task row cells and add the task durations. Make sure the following functions are imported from dataFunctions.js:

import {
  monthDiff,
  getDaysInMonth,
  getDayOfWeek,
  createFormattedDateFromStr, 
  createFormattedDateFromDate,
  dayDiff,
} from '../../helpers/dateFunctions';

Add the following for loop below the one that you added:

  // create task rows
  if (tasks) {
    tasks.forEach((task) => {
      let mnth = new Date(startMonth);
      for (let i = 0; i < numMonths; i++) {
        const curYear = mnth.getFullYear();
        const curMonth = mnth.getMonth() + 1;

        const numDays = getDaysInMonth(curYear, curMonth);

        for (let j = 1; j <= numDays; j++) {
          // color weekend cells differently
          const dayOfTheWeek = getDayOfWeek(curYear, curMonth - 1, j - 1);
          // add task and date data attributes
          const formattedDate = createFormattedDateFromStr(
            curYear,
            curMonth,
            j
          );

          taskRow.push(
            <div
              key={`${task.id}-${j}`}
              style={{
                ...ganttTimePeriodCell,
                backgroundColor:
                  dayOfTheWeek === 'S' ? 'var(--color-tertiary)' : '#fff',
              }}
              data-task={task?.id}
              data-date={formattedDate}
            >
              {taskDurations.map((el, i) => {
                if (el?.task === task?.id && el?.start === formattedDate) {
                  return (
                    <div
                      key={`${i}-${el?.id}`}
                      tabIndex="0"
                      style={{
                        ...taskDuration,
                        width: `calc(${dayDiff(el?.start, el?.end)} * 100% - 1px)`,
                      }}
                    ></div>
                  );
                }
              })}
            </div>
          );
        }

        taskRows.push(
          <div key={`${i}-${task?.id}`} style={ganttTimePeriod}>
            {taskRow}
          </div>
        );

        taskRow = [];
        mnth.setMonth(mnth.getMonth() + 1);
      }
    });
  }

We loop through each month as we did in the first for loop that we added. We use the nested for loop to create the cells. The data-attributes data-task and data-date are added to each cell. We'll use these when we add drag-and-drop functionality to the task durations. For each cell, we map over the taskDurations state and add a task duration <div> element as a child of the cell if the cell's task id and start date matches the task duration task and start properties. The width of the task duration element is determined by calculating the duration of the task duration using the dayDiff function and then multiplying it by 100% of the cell width using CSS.

Now you'll see the task rows and task durations in your app.

Making task durations deletable

Now let’s make our task durations deletable by pressing the delete button when the task duration is in focus. Add the following property to the task duration element, which is the <div> that's returned where the taskDurations are mapped over (taskDurations.map((el, i) => {):

onKeyDown={(e) => deleteTaskDuration(e, el?.id)}

Now let's create the deleteTaskDuration function below the two for loops:

  function deleteTaskDuration(e, id) {
    if (e.key === 'Delete' || e.key === 'Backspace') {
      // update taskDurations
      const newTaskDurations = taskDurations.filter(
        (taskDuration) => taskDuration.id !== id
      );
      // update state (if data on backend - make API request to update data)
      setTaskDurations(newTaskDurations);
    }
  }

The React SyntheticEvent and the task duration id are passed into the deleteTaskDuration function. If the "Delete" or "Backspace" key is pressed, a new state object is created by filtering out the deleted task from the taskDurations state, and the state is updated.

Adding drag-and-drop functionality to task durations

Let’s add drag-and-drop functionality to our task durations to change the position of the task duration elements on the grid. Add the following state and its setter:

  const [taskDurationElDraggedId, setTaskDurationElDraggedId] = useState(null);

The taskDurationElDraggedId state will keep track of the task duration id that is currently being dragged. Now add the following function below the deleteTaskDuration function:

  function handleDragStart(taskDurationId) {
    console.log(taskDurationId);
    setTaskDurationElDraggedId(taskDurationId);
  }

This function will handle setting the taskDurationElDraggedId state.

Now change the returned task duration <div> element to the following:

  <div
    key={`${i}-${el?.id}`}
    draggable="true"
    tabIndex="0"
    onDragStart={() => handleDragStart(el?.id)}
    style={{
      ...taskDuration,
      width: `calc(${dayDiff(
              el?.start,
              el?.end
      )} * 100% - 1px)`,
      opacity:
        taskDurationElDraggedId === el?.id ? '0.5' : '1',
    }}
    onKeyDown={(e) => deleteTaskDuration(e, el?.id)}
  ></div>

We set the draggable property of the task duration <div> element to true. Of course, we don’t need this property for our drag and drop to work, but it's good for UX because it creates a "ghost" image of the task duration element attached to the mouse cursor as it's dragged. We then call the handleDragStart function and pass in the task duration id as an argument when dragging of the task duration starts. We also made the opacity of the task duration decrease while dragging.

Also, while dragging, you'll see the task duration id in your dev tools console.

Add the following property to the task row cell, which has a data-task property:

onDrop={onTaskDurationDrop}

We add the onDrop attribute to define the drop event handler for each cell in the drag-and-drop zone of the grid, which is the task cells area. Dropping an element on a cell will trigger an onTaskDuration function call. Let’s define the onTaskDurationDrop function. Add the following lines below the handleDragStart function:

  function onTaskDurationDrop(e) {
    const targetCell = e.target;
    // prevent adding on another taskDuration
    if (!targetCell.hasAttribute('draggable')) {
      // find task
      const taskDuration = taskDurations.filter(
        (taskDuration) => taskDuration.id === taskDurationElDraggedId
      )[0];

      const dataTask = targetCell.getAttribute('data-task');
      const dataDate = targetCell.getAttribute('data-date');

      const daysDuration = dayDiff(taskDuration.start, taskDuration.end);

      // get new task values
      // get start, calc end using daysDuration - make Date objects - change taskDurations
      const newTask = parseInt(dataTask);
      const newStartDate = new Date(dataDate);
      let newEndDate = new Date(dataDate);
      newEndDate.setDate(newEndDate.getDate() + daysDuration - 1);

      // update taskDurations
      taskDuration.task = newTask;
      taskDuration.start = createFormattedDateFromDate(newStartDate);
      taskDuration.end = createFormattedDateFromDate(newEndDate);

      const newTaskDurations = taskDurations.filter(
        (taskDuration) => taskDuration.id !== taskDurationElDraggedId
      );
      newTaskDurations.push(taskDuration);

      // update state (if data on backend - make API request to update data)
      setTaskDurations(newTaskDurations);
    }
    setTaskDurationElDraggedId(null);
  }

We prevent a task duration from being added on top of another task duration by checking if the target cell has a draggable attribute. We then update the taskDuration state. We first find the task that was dragged and dropped, and remove it from a copy of the taskDurations state. We then create a new task duration and add it to the copied state. We use this copied and modified state to update the state.

If you now try to drag a task duration, you'll see that the cursor will turn to the "not-allowed" icon. This is because dragging and dropping an element inside of another element is disabled by default. To remove this default behavior in our drag-and-drop zone, add the following property to the <div> element with an id of gantt-time-period-cell-container:

onDragOver={(e) => e.preventDefault()}

Now that the drag-and-drop works, let's get the "Add Task" form working.

Making the "Add task" form functional

In the AddTask component, the form has an input element with an onChange event handler that updates the local state variable task. Submitting the form will call the handleSubmit function. We need to complete this function by updating the tasks state using the passed-in prop setTasks.

Set the new tasks state by adding the following state setter above setTask(''):

  setTasks((prevState) => {
    const newState = prevState;
    // find largest task number, add 1 for new task - else could end up with tasks with same id
    const maxIdVal = prevState.reduce(function (a, b) {
      return Math.max(a, b.id);
    }, -Infinity);

    // create new task
    newState.push({
      id: isFinite(maxIdVal) ? maxIdVal + 1 : 1,
      name: task,
    });

    return [...newState];
  });

We create a new task and add it to a copy of the state, newState, and then return it from setState to replace the state with the new state.

To determine the new task id, we use the reduce method to find the largest current task id, and then add one to it to create the id for the new task. The task id values are numbers that represent the order in which they were created. The tasks are sorted by their id.

You'll now be able to add tasks to your Gantt chart. When you add a task, the Gantt Chart is re-rendered, displaying the new tasks state.

Making the "Add task duration" form functional

The AddTaskDuration component is partly created for you, like the AddTask component was. We need to loop through the passed-in tasks state and populate the "Which tasks" <select> input. We also need to update the taskDuration state using the passed in setTaskDurations state setter.

The form has three inputs: a <select> input for selecting the task that the task duration is for, and two date inputs for selecting the start and end date of the task duration. The form state is managed using the three local state variables, task, startDate, and endDate, as well as their state setters. The onChange function handles updating the local state when an input value is changed.

First, let's populate the tasks <select> input with <option> elements for each task. Add the following code inside of the <select> input with an id of select-task:

  <option disabled defaultValue value="">
    select a task
  </option>
  {tasks &&
    tasks.map((tsk) => (
      <option key={tsk?.id} value={tsk?.id}>
        {tsk?.name}
      </option>
    ))}

Now you'll see that the <select> menu is populated with all the task names. If you add a task, you'll see that it's added to the <select> menu as the GanttChart component re-renders.

To get the handleSubmit function to work, add the following lines to it, below e.preventDefault():

  if (task === '') return;
  const timeStamp = Date.now();
  const newTaskDuration = {
    id: timeStamp,
    start: startDate,
    end: endDate,
    task: parseInt(task),
  };

  setTaskDurations((prevState) => {
    const newState = prevState;
    return [...newState, newTaskDuration];
  });

If a task has not been selected, we return. We then create a new task duration using the local state and a time stamp for the id. We then set the taskDurations state using setTaskDurations by returning a new array from the passed-in function.

You'll now be able to add new task durations to your Gantt chart.

Making the "Tracker period" functional

To complete the code for the TimeRange component, we need to give each <select> element the correct value using the passed-in timeRange state. We then need to update this state in the onChange handler function.

Replace the value props of the four <select> elements with the following value props:

// <select> with id="from-select-month""
value={timeRange.fromSelectMonth}

// <select> with id="from-select-year"
value={timeRange.fromSelectYear}

// <select> with id="to-select-month"
value={timeRange.toSelectMonth}

// <select> with id="to-select-year"
value={timeRange.toSelectYear}

Now add the following lines to the onChange function, below the line const { value, id } = e.target;:

  if (id === 'from-select-month') {
    setTimeRange((prevState) => {
      return { ...prevState, fromSelectMonth: value };
    });
  }
  if (id === 'from-select-year') {
    setTimeRange((prevState) => {
      return { ...prevState, fromSelectYear: value };
    });
  }
  if (id === 'to-select-month') {
    setTimeRange((prevState) => {
      return { ...prevState, toSelectMonth: value };
    });
  }
  if (id === 'to-select-year') {
    setTimeRange((prevState) => {
      return { ...prevState, toSelectYear: value };
    });
  }

When the value of one of the <select> inputs is changed, we update the timeRange state. This causes the GanttChart component to re-render, which will show the updated time range.

We've completed our basic Gantt chart, but the process was a little tedious and possibly not bug free. Now let's create a Gantt chart using our Bryntum Gantt component for comparison.

Using Bryntum Gantt with Next.js

To install Bryntum Gantt with npm you just need to install two libraries with zero external dependencies. If you are unfamiliar with Bryntum products, you can follow the guide here.

Let's import the Bryntum Gantt component. In the components folder, create a Gantt.js file and add the following lines:

import { BryntumGantt } from '@bryntum/gantt-react';

export default function Gantt({ ganttRef, ...props }) {
  return <BryntumGantt {...props} ref={ganttRef} />;
}

We'll use the imported BryntumGantt component. We'll pass in a config file as props to determine how the Gantt chart looks and where it gets data from. You can also pass in a ref if needed.

We need to import the BryntumGantt component dynamically. Create another component called GanttInstance.js and add the following code:

import dynamic from 'next/dynamic';
import { ganttConfig } from '../ganttConfig.js';

const Gantt = dynamic(() => import('../components/Gantt.js'), {
  ssr: false,
  loading: () => {
    return (
      <div
        style={{
          display: 'flex',
          alignItems: 'center',
          justifyContent: 'center',
          height: '100vh',
        }}
      >
        <p>Loading...</p>
      </div>
    );
  },
});

const GanttInstance = () => {
  return (
    <>
      <Gantt
        {...ganttConfig}
        // other props
      />
    </>
  );
};

export { GanttInstance };

In the project's root folder, create a ganttConfig.js file and add the following code:

/**
 * Application configuration
 */

const ganttConfig = {
  columns: [{ type: 'name', field: 'name', width: 250 }],
  viewPreset: 'weekAndDayLetter',
  barMargin: 10,
  project: {
    transport: {
      load: {
        url: 'data/gantt-data.json',
      },
    },
    autoLoad: true,
  },
};

export { ganttConfig };

We pass in the configuration from ganttConfig.js to the Gantt component. This includes the columns property to create the Gantt chart columns for the tasks. You can learn more about the config options in the Bryntum docs.
We configure the project with the transport property to populate the Gantt chart's data stores. We've configured the url to load data using the load property. The url data source is a JSON file in the public folder of the starter repository. You can also configure the transport to sync data changes to a specific url. For more information, you can read the following guide in our docs: Binding Bryntum Gantt data.

We dynamically import the Gantt component with ssr set to false. While the component is loading, we display a loading component that returns a <p> tag with the message "Loading...".

In order for the Gantt chart's data population to work, we need to turn off strict mode. Set reactStrictMode to false in the next.config.js file, which is in the project's root folder:

/** @type {import('next').NextConfig} */
const nextConfig = {
  reactStrictMode: false,
  swcMinify: true,
};

module.exports = nextConfig;

Let's create a page to view our Bryntum Gantt chart. In the pages folder, create a file named bryntum.js and add the following lines to it:

import Head from 'next/head';
import { GanttInstance } from '../components/GanttInstance';
import '@bryntum/gantt/gantt.stockholm.css';

export default function BryntumGanttPage() {
  return (
    <div className="container">
      <Head>
        <title>
          Creating a Gantt chart with React using Next.js and Bryntum
        </title>
        <link rel="icon" href="/favicon.ico" />
      </Head>
      <GanttInstance></GanttInstance>
      <style jsx>{`
        .container {
          height: 100vh;
        }
      `}</style>
    </div>
  );
}

We import our GanttInstance component and the CSS for the Bryntum Gantt Stockholm theme, which is one of five available themes. You can see a demo showing the different themes here. You can also create custom themes. In this demo, you can also learn about the different components of the Gantt chart by clicking on the "Learn" button in the top right corner.

The GanttInstance component is wrapped in a <div> with a class of container. We give it a height of 100vh so that the Gantt chart fills the whole screen.

In your app, go to the bryntum route by going to the following url: http://localhost:3000/bryntum. You'll now see the Bryntum Gantt chart.

This basic example of the Bryntum Gantt component has more features by default than the Gantt chart that we created. The features include:

• Collapsible task groups.
• Drag-and-drop re-ordering of tasks.
• Add, edit, copy, and delete tasks. Right-click on a task to see a pop-up menu with these actions.
• Draggable task durations.
• Re-sizeable task durations. Hover your mouse over the left or right side of a task duration, which is green, until the cursor changes to a resize icon. Then click and hold down while you move your mouse left or right.

Try out some of these features in your app.

Comparing the vanilla JS, React, and Bryntum Gantt charts

Let's compare the Gantt chart that we created with the basic example of the Bryntum Gantt chart, as well as the vanilla JavaScript one that we created in a previous article.

Breaking the React Gantt chart into different components, organizing code, and managing state was easier than when vanilla JavaScript was used. React manages state declaratively, which makes managing it easier. The vanilla JavaScript Gantt chart required a lot of direct DOM manipulation, selecting DOM elements and adding events to them. The code of the vanilla JavaScript Gantt chart and React Gantt chart are quite similar, however because we used Next.js, we had to take SSR into account.

The Bryntum Gantt chart was easy to set up, it has a very customizable API that you can learn about in the API docs. You can see all the available features here and view an advanced demo of a React Gantt chart here. The advanced demo includes features such as highlighting critical paths, theme selection, and undoing or redoing actions.

The Bryntum Gantt chart is built with pure JavaScript/ES6+ and it uses a very fast rendering engine. Its performance is great even with large datasets. You can test this yourself: Return to your local development server and set the Tracker Period in the custom-built Gantt to its maximum range and add a new task. You'll notice that it takes a couple of seconds for the new task to be added. This is because there are many cells to render. Try this with the live example of the vanilla JavaScript Gantt from the previous article as well. You'll notice the same thing.

Now change the date range of the project in the chart that you created with the Bryntum Gantt component. Make the date range 1000 years and then add a task. There is no noticeable difference in performance.

Next steps

There are many ways you can add to or improve the Gantt chart component as described in the "Next Steps" section of our previous article where we used vanilla JavaScript to create a Gantt chart. Unlike the vanilla JavaScript Gantt chart, you don't need to worry about sanitizing the task and task duration data with React.

You can improve the Gantt chart by adding input validation. State management can also be improved by preventing unnecessary re-renders. The TimeTable component renders the table using many nested loops. Minimizing the number of nested loops would improve performance.

Build or buy?

This article gives you a starting point for building your own React Gantt chart using Next.js. If you’re instead looking to buy an off-the-shelf, battle-tested solution that just works, take a look at some examples of our Bryntum Gantt. With the Bryntum Gantt component, you can:

• Schedule tasks using dependencies and constraints.
• Leverage calendars for projects, tasks, and resources.
• Use recurrent and fixed time intervals.
• Customize rendering and styling.
• Customize user experience through many different column types and task editors.
• Deal with extensive datasets and performance tuning.

We also have a support forum and offer professional services.