Creating An Interactive Gantt Chart Element With Vanilla.js

No Comments

In the event you work with time knowledge in your app, a graphical visualization as a calendar or Gantt chart is usually very helpful. At first look, creating your individual chart part appears fairly difficult. Subsequently, on this article, I’ll develop the muse for a Gantt chart part whose look and performance you may customise for any use case.

These are the primary options of the Gantt chart that I wish to implement:

The consumer can select between two views: yr/month or month/day.
The consumer can outline the planning horizon by deciding on a begin date and an finish date.
The chart renders a given record of jobs that may be moved by drag and drop. The adjustments are mirrored within the state of the objects.
Beneath you may see the ensuing Gantt chart in each views. Within the month-to-month model, I’ve included three jobs for example.

Beneath you may see the ensuing Gantt chart in each views. Within the month-to-month model, I’ve included three jobs for example.

Pattern Recordsdata And Directions For Working The Code

You’ll find the full code snippets of this text within the following recordsdata:


Because the code comprises JavaScript modules, you may solely run the instance from an HTTP server and never from the native file system. For testing in your native PC, I’d advocate the module live-server, which you’ll be able to set up by way of npm.

Alternatively, you may check out the instance right here immediately in your browser with out set up.

Fundamental Construction Of The Internet Element

I made a decision to implement the Gantt chart as an internet part. This permits us to create a customized HTML factor, in my case <gantt-chart></gantt-chart>, which we are able to simply reuse anyplace on any HTML web page.

You’ll find some primary details about creating internet parts within the MDN Internet Docs. The next itemizing reveals the construction of the part. It’s impressed by the “counter” instance from

The part defines a template containing the HTML code wanted to show the Gantt chart. For the whole CSS specs, please seek advice from the pattern recordsdata. The particular choice fields for yr, month or date can’t be outlined right here but, as they rely on the chosen degree of the view.

The choice parts are projected in by one of many two renderer lessons as an alternative. The identical applies to the rendering of the particular Gantt chart into the factor with the ID gantt-container, which can be dealt with by the accountable renderer class.

The category VanillaGanttChart now describes the conduct of our new HTML factor. Within the constructor, we first outline our tough template because the shadow DOM of the factor.

The part have to be initialized with two arrays, jobs, and assets. The roles array comprises the duties which can be displayed within the chart as movable inexperienced bars. The assets array defines the person rows within the chart the place duties may be assigned. Within the screenshots above, for instance, we now have 4 assets labeled Job 1 to Job 4. The assets can subsequently signify the person duties, but in addition folks, autos, and different bodily assets, permitting for quite a lot of use circumstances.

At the moment, the YearMonthRenderer is used because the default renderer. As quickly because the consumer selects a unique degree, the renderer is modified within the changeLevel methodology: First, the renderer-specific DOM parts and listeners are deleted from the Shadow DOM utilizing the clear methodology of the previous renderer. Then the brand new renderer is initialized with the present jobs and assets and the rendering is began.

import {YearMonthRenderer} from ‘./YearMonthRenderer.js’;
import {DateTimeRenderer} from ‘./DateTimeRenderer.js’;

const template = doc.createElement(‘template’);

template.innerHTML =
`<model> … </model>

<div id=”gantt-settings”>

<choose identify=”select-level” id=”select-level”>
<possibility worth=”year-month”>Month / Day</possibility>
<possibility worth=”day”>Day / Time</possibility>

<fieldset id=”select-from”>

<fieldset id=”select-to”>

<div id=”gantt-container”>

export default class VanillaGanttChart extends HTMLElement {

constructor() {
this.attachShadow({ mode: ‘open’ });
this.shadowRoot.appendChild(template.content material.cloneNode(true));
this.levelSelect = this.shadowRoot.querySelector(‘#select-level’);

_resources = [];
_jobs = [];

set assets(record){…}
get assets(){…}
set jobs(record){…}
get jobs(){…}
get degree() {…}
set degree(newValue) {…}
get renderer(){…}
set renderer(r){…}

connectedCallback() {
this.changeLevel = this.changeLevel.bind(this);

this.levelSelect.addEventListener(‘change’, this.changeLevel); = “year-month”;

this.renderer = new YearMonthRenderer(this.shadowRoot);
this.renderer.dateFrom = new Date(2021,5,1);
this.renderer.dateTo = new Date(2021,5,24);

disconnectedCallback() {
this.levelSelect.removeEventListener(‘change’, this.changeLevel);


var r;

if( == “year-month”){
r = new YearMonthRenderer(this.shadowRoot);
r = new DateTimeRenderer(this.shadowRoot);

r.dateFrom = new Date(2021,5,1);
r.dateTo = new Date(2021,5,24);
r.assets = this.assets; =;
this.renderer = r;

window.customElements.outline(‘gantt-chart’, VanillaGanttChart);

Earlier than we get deeper into the rendering course of, I wish to provide you with an outline of the connections between the totally different scripts:

index.html is your internet web page the place you should utilize the tag <gantt-chart></gantt-chart>
index.js is a script during which you initialize the occasion of the online part that’s related to the Gantt chart utilized in index.html with the suitable jobs and assets (after all you can even use a number of Gantt charts and thus a number of situations of the online part)
The part VanillaGanttChart delegates rendering to the 2 renderer lessons YearMonthRenderer and DateTimeRenderer.

Rendering Of The Gantt chart With JavaScript And CSS Grid

Within the following, we focus on the rendering course of utilizing the YearMonthRenderer for example. Please word that I’ve used a so-called constructor perform as an alternative of the category key phrase to outline the category. This permits me to differentiate between public properties (this.render and this.clear) and personal variables (outlined with var).

The rendering of the chart is damaged down into a number of sub-steps:

Rendering of the controls that are used to outline the planning horizon.
Rendering of the Gantt chart, mainly in 4 steps:
initFirstRow (attracts 1 row with month names)
initSecondRow (attracts 1 row with days of the month)
initGanttRows (attracts 1 row for every useful resource with grid cells for every day of the month)
initJobs (positions the draggable jobs within the chart)

export perform YearMonthRenderer(root){

var shadowRoot = root;
var names = [“Jan”, “Feb”, “Mar”, “Apr”, “May”, “Jun”, “Jul”, “Aug”, “Sep”, “Oct”, “Nov”, “Dec”];

this.assets=[]; = [];

this.dateFrom = new Date();
this.dateTo = new Date();

//choose parts
var monthSelectFrom;
var yearSelectFrom;
var monthSelectTo;
var yearSelectTo;

var getYearFrom = perform() {…}
var setYearFrom = perform(newValue) {…}

var getYearTo = perform() {…}
var setYearTo = perform(newValue) {…}

var getMonthFrom = perform() {…}
var setMonthFrom = perform(newValue) {…}

var getMonthTo = perform() {…}
var setMonthTo = perform(newValue) {…}

this.render = perform(){

//take away choose parts and listeners, clear gantt-container
this.clear = perform(){…}

//add HTML code for the settings space (choose parts) to the shadow root, initialize related DOM parts and assign them to the properties monthSelectFrom, monthSelectTo and so forth., initialize listeners for the choose parts
var initSettings = perform(){…}

//add HTML code for the gantt chart space to the shadow root, place draggable jobs within the chart
var initGantt = perform(){…}

//utilized by initGantt: draw time axis of the chart, month names
var initFirstRow = perform(){…}

//utilized by initGantt: draw time axis of the chart, days of month
var initSecondRow = perform(){…}

//utilized by initGantt: draw the remaining grid of the chart
var initGanttRows = perform(){…}.bind(this);

//utilized by initGantt: place draggable jobs within the chart cells
var initJobs = perform(){…}.bind(this);

//drop occasion listener for jobs
var onJobDrop = perform(ev){…}.bind(this);

//helper features, see instance recordsdata


Rendering The Grid

I like to recommend CSS Grid for drawing the diagram space as a result of it makes it very straightforward to create multi-column layouts that adapt dynamically to the display screen measurement.

In step one, we now have to find out the variety of columns of the grid. In doing so, we seek advice from the primary row of the chart which (within the case of the YearMonthRenderer) represents the person months.

Consequently, we want:

one column for the names of the assets, e.g. with a hard and fast width of 100px.
one column for every month, of the identical measurement and utilizing the total area accessible.

This may be achieved with the setting 100px repeat(${n_months}, 1fr) for the property gridTemplateColumns of the chart container.

That is the preliminary a part of the initGantt methodology:

var container = shadowRoot.querySelector(“#gantt-container”);
container.innerHTML = “”;

var first_month = new Date(getYearFrom(), getMonthFrom(), 1);
var last_month = new Date(getYearTo(), getMonthTo(), 1);

//monthDiff is outlined as a helper perform on the finish of the file
var n_months = monthDiff(first_month, last_month)+1;

container.model.gridTemplateColumns = `100px repeat(${n_months},1fr)`;

Within the following image you may see a chart for 2 months with n_months=2:

After we now have outlined the outer columns, we are able to begin filling the grid. Let’s stick with the instance from the image above. Within the first row, I insert 3 divs with the lessons gantt-row-resource and gantt-row-period. You’ll find them within the following snippet from the DOM inspector.

Within the second row, I take advantage of the identical three divs to maintain the vertical alignment. Nevertheless, the month divs get baby parts for the person days of the month.

<div id=”gantt-container”
model=”grid-template-columns: 100px repeat(2, 1fr);”>
<div class=”gantt-row-resource”></div>
<div class=”gantt-row-period”>Jun 2021</div>
<div class=”gantt-row-period”>Jul 2021</div>
<div class=”gantt-row-resource”></div>
<div class=”gantt-row-period”>
<div class=”gantt-row-period”>1</div>
<div class=”gantt-row-period”>2</div>
<div class=”gantt-row-period”>3</div>
<div class=”gantt-row-period”>4</div>
<div class=”gantt-row-period”>5</div>
<div class=”gantt-row-period”>6</div>
<div class=”gantt-row-period”>7</div>
<div class=”gantt-row-period”>8</div>
<div class=”gantt-row-period”>9</div>
<div class=”gantt-row-period”>10</div>



For the kid parts to be organized horizontally as properly, we want the setting show: grid for the category gantt-row-period. As well as, we have no idea precisely what number of columns are required for the person months (28, 30, or 31). Subsequently, I take advantage of the setting grid-auto-columns. With the worth minmax(20px, 1fr); I can make sure that a minimal width of 20px is maintained and that in any other case the accessible area is absolutely utilized:

#gantt-container {
show: grid;

.gantt-row-resource {
background-color: whitesmoke;
shade: rgba(0, 0, 0, 0.726);
border: 1px strong rgb(133, 129, 129);
text-align: middle;

.gantt-row-period {
show: grid;
grid-auto-flow: column;
grid-auto-columns: minmax(20px, 1fr);
background-color: whitesmoke;
shade: rgba(0, 0, 0, 0.726);
border: 1px strong rgb(133, 129, 129);
text-align: middle;

The remaining rows are generated in accordance with the second row, nonetheless as empty cells.

Right here is the JavaScript code for producing the person grid cells of the primary row. The strategies initSecondRow and initGanttRows have an analogous construction.

var initFirstRow = perform(){

var container = shadowRoot.querySelector(“#gantt-container”);

var first_month = new Date(getYearFrom(), getMonthFrom(), 1);
var last_month = new Date(getYearTo(), getMonthTo(), 1);

var useful resource = doc.createElement(“div”);
useful resource.className = “gantt-row-resource”;
container.appendChild(useful resource);

var month = new Date(first_month);

for(month; month <= last_month; month.setMonth(month.getMonth()+1)){
var interval = doc.createElement(“div”);
interval.className = “gantt-row-period”;
interval.innerHTML = names[month.getMonth()] + ” ” + month.getFullYear();

Rendering The Jobs

Now every job needs to be drawn into the diagram on the appropriate place. For this I make use of the HTML knowledge attributes: each grid cell in the principle chart space is related to the 2 attributes data-resource and data-date indicating the place on the horizontal and vertical axis of the chart (see perform initGanttRows within the recordsdata YearMonthRenderer.js and DateTimeRenderer.js).

For example, let’s take a look at the first 4 grid cells within the first row of the chart (we’re nonetheless utilizing the identical instance as within the footage above):

Within the DOM inspector you may see the values of the info attributes that I’ve assigned to the person cells:

Let’s now see what this implies for the perform initJobs. With the assistance of the perform querySelector, it’s now fairly straightforward to search out the grid cell into which a job ought to be positioned.

The subsequent problem is to find out the right width for a job factor. Relying on the chosen view, every grid cell represents a unit of sooner or later (degree month/day) or one hour (degree day/time). Since every job is the kid factor of a cell, the job length of 1 unit (day or hour) corresponds to a width of 1*100%, the length of two items corresponds to a width of two*100%, and so forth. This makes it potential to make use of the CSS calc perform to dynamically set the width of a job factor, as proven within the following itemizing.

var initJobs = perform(){ => {

var date_string = formatDate(job.begin);

var ganttElement = shadowRoot.querySelector(`div[data-resource=”${job.resource}”][data-date=”${date_string}”]`);


var jobElement = doc.createElement(“div”);
jobElement.className=”job”; =;

//helper perform dayDiff – get distinction between begin and finish in days
var d = dayDiff(job.begin, job.finish);

//d –> variety of grid cells coated by job + sum of borderWidths
jobElement.model.width = “calc(“+(d*100)+”% + “+ d+”px)”;
jobElement.draggable = “true”;

jobElement.ondragstart = perform(ev){
//the id is used to establish the job when it’s dropped


As a way to make a job draggable, there are three steps required:

Set the property draggable of the job factor to true (see itemizing above).
Outline an occasion handler for the occasion ondragstart of the job factor (see itemizing above).
Outline an occasion handler for the occasion ondrop for the grid cells of the Gantt chart, that are the potential drop targets of the job factor (see perform initGanttRows within the file YearMonthRenderer.js).

The occasion handler for the occasion ondrop is outlined as follows:

var onJobDrop = perform(ev){

// primary null checks
if (checkElements()) {


// drop goal = grid cell, the place the job is about to be dropped
var gantt_item = ev.goal;

// forestall {that a} job is appended to a different job and to not a grid cell
if (ev.goal.classList.comprises(“job”)) {
gantt_item = ev.goal.parentNode;

// establish the dragged job
var knowledge = ev.dataTransfer.getData(“job”);
var jobElement = shadowRoot.getElementById(knowledge);

// drop the job

// replace the properties of the job object
var job = => == knowledge );

var begin = new Date(gantt_item.getAttribute(“data-date”));
var finish = new Date(begin);
finish.setDate(begin.getDate()+dayDiff(job.begin, job.finish));

job.begin = begin;
job.finish = finish;
job.useful resource = gantt_item.getAttribute(“data-resource”);

All adjustments to the job knowledge made by drag and drop are thus mirrored within the record jobs of the Gantt chart part.

Integrating The Gantt Chart Element In Your Utility

You need to use the tag <gantt-chart></gantt-chart> anyplace within the HTML recordsdata of your software (in my case within the file index.html) below the next circumstances:

The script VanillaGanttChart.js have to be built-in as a module in order that the tag is interpreted appropriately.
You want a separate script during which the Gantt chart is initialized with jobs and assets (in my case the file index.js).

<!DOCTYPE html>
<meta charset=”UTF-8″/>
<title>Gantt chart – Vanilla JS</title>
<script sort=”module” src=”VanillaGanttChart.js”></script>


<gantt-chart id=”g1″></gantt-chart>

<script sort=”module” src=”index.js”></script>

For instance, in my case the file index.js appears to be like as follows:

import VanillaGanttChart from “./VanillaGanttChart.js”;

var chart = doc.querySelector(“#g1”); = [
{id: “j1”, start: new Date(“2021/6/1”), end: new Date(“2021/6/4”), resource: 1},
{id: “j2”, start: new Date(“2021/6/4”), end: new Date(“2021/6/13”), resource: 2},
{id: “j3”, start: new Date(“2021/6/13”), end: new Date(“2021/6/21”), resource: 3},

chart.assets = [{id:1, name: “Task 1”}, {id:2, name: “Task 2”}, {id:3, name: “Task 3”}, {id:4, name: “Task 4”}];

Nevertheless, there may be nonetheless one requirement open: when the consumer makes adjustments by dragging jobs within the Gantt chart, the respective adjustments within the property values of the roles ought to be mirrored within the record exterior the part.

We will obtain this with using JavaScript Proxy Objects: Every job is nested in a proxy object, which we offer with a so-called validator. It turns into lively as quickly as a property of the article is modified (perform set of the validator) or retrieved (perform get of the validator). Within the set perform of the validator, we are able to retailer code that’s executed every time the beginning time or the useful resource of a process is modified.

The next itemizing reveals a unique model of the file index.js. Now an inventory of proxy objects is assigned to the Gantt chart part as an alternative of the unique jobs. Within the validator set I take advantage of a easy console output to point out that I’ve been notified of a property change.

import VanillaGanttChart from “./VanillaGanttChart.js”;

var chart = doc.querySelector(“#g1”);

var jobs = [
{id: “j1”, start: new Date(“2021/6/1”), end: new Date(“2021/6/4”), resource: 1},
{id: “j2”, start: new Date(“2021/6/4”), end: new Date(“2021/6/13”), resource: 2},
{id: “j3”, start: new Date(“2021/6/13”), end: new Date(“2021/6/21”), resource: 3},
var p_jobs = [];

chart.assets = [{id:1, name: “Task 1”}, {id:2, name: “Task 2”}, {id:3, name: “Task 3”}, {id:4, name: “Task 4”}];

jobs.forEach(job => {

var validator = {
set: perform(obj, prop, worth) {

console.log(“Job ” + + “: ” + prop + ” was modified to ” + worth);

obj[prop] = worth;
return true;

get: perform(obj, prop){

return obj[prop];

var p_job = new Proxy(job, validator);
}); = p_jobs;


The Gantt chart is an instance that reveals how you should utilize the applied sciences of Internet Elements, CSS Grid, and JavaScript Proxy to develop a customized HTML factor with a considerably extra advanced graphical interface. You’re welcome to develop the mission additional and/or use it in your individual initiatives along with different JavaScript frameworks.

Once more, you will discover all pattern recordsdata and directions on the prime of the article.

    About Marketing Solution Australia

    We are a digital marketing company with a focus on helping our customers achieve great results across several key areas.

    Request a free quote

    We offer professional SEO services that help websites increase their organic search score drastically in order to compete for the highest rankings even when it comes to highly competitive keywords.

    Subscribe to our newsletter!

    More from our blog

    See all posts

    Leave a Comment