Usage
WeekView displays events of a week in time slots:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
/>
);
}Controlled date
Use date and onDateChange props to control the displayed date:
Nov 16 – Nov 22, 2026
import { useState } from 'react';
import dayjs from 'dayjs';
import { WeekView } from '@mantine/schedule';
import { Button, Group, Text } from '@mantine/core';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const weekStart = dayjs(date).subtract((dayjs(date).day() + 6) % 7, 'day');
return (
<div>
<Group mb="md">
<Button onClick={() => setDate(dayjs(date).subtract(1, 'week').format('YYYY-MM-DD HH:mm:ss'))}>
Previous Week
</Button>
<Text fw={500}>{weekStart.format('MMM D')} – {weekStart.add(6, 'day').format('MMM D, YYYY')}</Text>
<Button onClick={() => setDate(dayjs(date).add(1, 'week').format('YYYY-MM-DD HH:mm:ss'))}>
Next Week
</Button>
</Group>
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
/>
</div>
);
}Time range
Use startTime and endTime props to set the visible time range:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="09:00:00"
endTime="17:00:00"
/>
);
}Start scroll time
Use startScrollTime prop to set the initial scroll position, for example to open the view
at the start of business hours instead of midnight:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events as initialEvents } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const [events, setEvents] = useState(initialEvents);
const handleEventDrop = ({ eventId, newStart, newEnd }: { eventId: string | number; newStart: string; newEnd: string }) => {
setEvents((prev) =>
prev.map((event) =>
event.id === eventId ? { ...event, start: newStart, end: newEnd } : event
)
);
};
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startScrollTime="09:00:00"
scrollAreaProps={{ mah: 500 }}
withEventsDragAndDrop
onEventDrop={handleEventDrop}
/>
);
}Interval minutes
intervalMinutes prop sets the time slot length in minutes:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
intervalMinutes={30}
/>
);
}Slot label interval
By default, the time column shows one label per hour. Set slotLabelInterval prop to display
labels more often, for example every 15 or 30 minutes. The value must be a multiple of
intervalMinutes, other values are rounded up to the next valid one. Increase slotHeight so
that the labels have enough space:
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
return (
<WeekView
date={new Date()}
events={events}
startTime="08:00:00"
endTime="18:00:00"
intervalMinutes={30}
slotLabelInterval={30}
slotHeight={120}
/>
);
}Sub-hour grid lines
Set withSubHourGridLines={false} to display one grid line per hour when intervalMinutes is smaller than 60.
Events are still created and resized with the smaller interval:
import { useState } from 'react';
import dayjs from 'dayjs';
import { WeekView, ScheduleEventData } from '@mantine/schedule';
const today = dayjs().format('YYYY-MM-DD');
const tomorrow = dayjs().add(1, 'day').format('YYYY-MM-DD');
const initialEvents: ScheduleEventData[] = [
{
id: 1,
title: 'Morning Standup',
start: `${today} 09:00:00`,
end: `${today} 09:30:00`,
color: 'blue',
},
{
id: 2,
title: 'Team Meeting',
start: `${tomorrow} 11:15:00`,
end: `${tomorrow} 12:00:00`,
color: 'green',
},
{
id: 3,
title: 'Code Review',
start: `${today} 14:00:00`,
end: `${today} 14:45:00`,
color: 'violet',
},
];
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const [events, setEvents] = useState(initialEvents);
const handleEventResize = ({ eventId, newStart, newEnd }: { eventId: string | number; newStart: string; newEnd: string }) => {
setEvents((prev) =>
prev.map((event) =>
event.id === eventId ? { ...event, start: newStart, end: newEnd } : event
)
);
};
// Events snap to 15 minutes increments, but only one grid line per hour is displayed
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
intervalMinutes={15}
withSubHourGridLines
withEventResize
onEventResize={handleEventResize}
/>
);
}First day of week
Set firstDayOfWeek to change the first day of the week, 0 is Sunday, 1 is Monday:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
firstDayOfWeek={0}
/>
);
}Weekday format
Use weekdayFormat prop to change the dayjs format of weekday names:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
weekdayFormat="dd"
/>
);
}Without weekend days
Set withWeekendDays={false} to hide Saturday and Sunday columns:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
withWeekendDays={false}
/>
);
}Highlight today
Set highlightToday to visually distinguish today's column:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
highlightToday
/>
);
}Without week number
Set withWeekNumber={false} to hide the week number in the top-left corner:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
withWeekNumber={false}
/>
);
}Current time indicator
A line at the current time is displayed in today's column by default.
Set withCurrentTimeIndicator={false} to hide it:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
withCurrentTimeIndicator
withCurrentTimeBubble
/>
);
}Force current time indicator
Set forceCurrentTimeIndicator to display the indicator on the same weekday in every week:
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState('2030-06-10');
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
withCurrentTimeIndicator
forceCurrentTimeIndicator
/>
);
}Current time indicator in a different timezone
The indicator is positioned based on the user's local time, @mantine/schedule does not convert timezones.
To display it in a different timezone, return the current time from getCurrentTime prop.
The example below uses the dayjs timezone plugin:
import { useState } from 'react';
import dayjs from 'dayjs';
import timezone from 'dayjs/plugin/timezone';
import utc from 'dayjs/plugin/utc';
import { Select, Stack } from '@mantine/core';
import { WeekView } from '@mantine/schedule';
import { getEvents } from './data';
dayjs.extend(utc);
dayjs.extend(timezone);
const timezones = ['UTC', 'America/New_York', 'Europe/Berlin', 'Asia/Kolkata', 'Asia/Tokyo'];
function Demo() {
const [tz, setTz] = useState('UTC');
// getCurrentTime is called on every tick, so the indicator keeps updating
const getCurrentTime = () => dayjs().tz(tz).format('YYYY-MM-DD HH:mm:ss');
const currentDate = getCurrentTime().split(' ')[0];
const [date, setDate] = useState(currentDate);
return (
<Stack>
<Select
label="Display timezone"
data={timezones}
value={tz}
onChange={(value) => {
setTz(value!);
setDate(dayjs().tz(value!).format('YYYY-MM-DD'));
}}
allowDeselect={false}
/>
<WeekView
date={date}
onDateChange={setDate}
events={getEvents(currentDate)}
getCurrentTime={getCurrentTime}
startScrollTime={dayjs(getCurrentTime()).subtract(2, 'hour').format('HH:mm:ss')}
withCurrentTimeIndicator
withCurrentTimeBubble
/>
</Stack>
);
}Without all-day slots
Set withAllDaySlots={false} to hide the all-day section at the top:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
withAllDaySlots={false}
/>
);
}All-day events
Events that span midnight or cover a full day are displayed in the all-day section at the top:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView, ScheduleEventData } from '@mantine/schedule';
const startOfWeek = dayjs().subtract((dayjs().day() + 6) % 7, 'day').format('YYYY-MM-DD');
const dayAfterStartOfWeek = dayjs(startOfWeek).add(1, 'day').format('YYYY-MM-DD');
const twoDaysAfter = dayjs(startOfWeek).add(2, 'day').format('YYYY-MM-DD');
const events: ScheduleEventData[] = [
{
id: 1,
title: 'Conference Day',
start: `${startOfWeek} 00:00:00`,
end: dayjs(startOfWeek).add(1, 'day').startOf('day').format('YYYY-MM-DD HH:mm:ss'),
color: 'red',
},
{
id: 2,
title: 'Holiday',
start: `${dayAfterStartOfWeek} 00:00:00`,
end: dayjs(dayAfterStartOfWeek).add(1, 'day').startOf('day').format('YYYY-MM-DD HH:mm:ss'),
color: 'pink',
},
{
id: 3,
title: 'Team Building',
start: `${startOfWeek} 00:00:00`,
end: dayjs(twoDaysAfter).add(1, 'day').startOf('day').format('YYYY-MM-DD HH:mm:ss'),
color: 'orange',
},
{
id: 4,
title: 'Morning Standup',
start: `${startOfWeek} 09:00:00`,
end: `${startOfWeek} 09:30:00`,
color: 'blue',
},
{
id: 5,
title: 'Code Review',
start: `${dayAfterStartOfWeek} 14:00:00`,
end: `${dayAfterStartOfWeek} 15:00:00`,
color: 'violet',
},
];
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
/>
);
}Without header
Set withHeader={false} to hide the header:
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
return (
<WeekView
date={new Date()}
events={events}
startTime="08:00:00"
endTime="18:00:00"
withHeader={false}
/>
);
}View change callback
onViewChange is called when the user picks another view in the header:
Selected view: week
import { useState } from 'react';
import dayjs from 'dayjs';
import { WeekView, ScheduleViewLevel } from '@mantine/schedule';
import { Text } from '@mantine/core';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const [view, setView] = useState<ScheduleViewLevel>('week');
return (
<div>
<Text mb="md">Selected view: {view}</Text>
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
onViewChange={setView}
/>
</div>
);
}Custom header
Set withHeader={false} and build your own header with ScheduleHeader compound components:
import dayjs from 'dayjs';
import { useState } from 'react';
import {
DateStringValue,
getStartOfWeek,
ScheduleHeader,
WeekView,
} from '@mantine/schedule';
import { events } from './data';
function getWeekRangeLabel(date: DateStringValue) {
const start = dayjs(getStartOfWeek({ date, firstDayOfWeek: 1 }));
const end = start.add(6, 'day');
if (start.month() === end.month()) {
return `${start.format('MMM D')} – ${end.format('D, YYYY')}`;
}
return `${start.format('MMM D')} – ${end.format('MMM D, YYYY')}`;
}
function Demo() {
const [date, setDate] = useState<DateStringValue>(
dayjs().format('YYYY-MM-DD')
);
return (
<div>
<ScheduleHeader>
<ScheduleHeader.Previous
onClick={() =>
setDate(
dayjs(date)
.subtract(1, 'week')
.format('YYYY-MM-DD') as DateStringValue
)
}
/>
<ScheduleHeader.Control interactive={false} miw={200}>
{getWeekRangeLabel(date)}
</ScheduleHeader.Control>
<ScheduleHeader.Next
onClick={() =>
setDate(
dayjs(date)
.add(1, 'week')
.format('YYYY-MM-DD') as DateStringValue
)
}
/>
<ScheduleHeader.Today
onClick={() =>
setDate(
dayjs().format('YYYY-MM-DD') as DateStringValue
)
}
/>
<ScheduleHeader.Control
style={{ marginInlineStart: 'auto' }}
onClick={() => window.print()}
>
Print
</ScheduleHeader.Control>
</ScheduleHeader>
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
withHeader={false}
/>
</div>
);
}Week label format
Use weekLabelFormat prop to change the week range format in the header.
The year is appended to the label unless the format already includes it:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
weekLabelFormat="MMMM D, YYYY"
/>
);
}Slot label format
Use slotLabelFormat prop to change the format of time labels:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
slotLabelFormat="h A"
/>
);
}Slot height
Use slotHeight to set the height of a one-hour slot and allDaySlotHeight to set the height of the all-day section:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
slotHeight={80}
allDaySlotHeight={60}
/>
);
}Radius
Use radius prop to change the border radius of the view and events:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
radius={0}
/>
);
}Business hours
Set highlightBusinessHours to highlight business hours, set businessHours to a tuple of start and end times in HH:mm:ss or HH:mm format to change the range:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
highlightBusinessHours
businessHours={['09:00:00', '17:00:00']}
/>
);
}Business hours do not need to align with the slot grid. When a boundary falls inside a slot, the slot and the time label next to it are painted up to the exact minute:
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
return (
<WeekView
date={new Date()}
events={events}
highlightBusinessHours
businessHours={['07:42', '19:01']}
intervalMinutes={30}
/>
);
}Business hours per day
Pass an object to businessHours to set a range per weekday, keys are day numbers from 0 (Sunday) to 6.
Days missing from the object or set to null have no business hours:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
highlightBusinessHours
businessHours={{
1: ['09:00:00', '17:00:00'],
2: ['09:00:00', '17:00:00'],
3: ['09:00:00', '17:00:00'],
4: ['09:00:00', '17:00:00'],
5: ['09:00:00', '13:00:00'],
}}
startTime="07:00:00"
endTime="20:00:00"
/>
);
}Business hours colors
Set --week-view-business-hours-bg and --week-view-non-business-hours-bg CSS variables
with vars prop or in CSS to change the colors. Both variables apply to time slots and time labels:
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
return (
<WeekView
date={new Date()}
events={events}
highlightBusinessHours
businessHours={['07:42', '19:01']}
vars={() => ({
weekView: {
'--week-view-business-hours-bg': 'var(--mantine-color-yellow-light)',
'--week-view-non-business-hours-bg': 'var(--mantine-color-blue-light)',
},
})}
/>
);
}Custom time slot props
Use getTimeSlotProps to add props to individual time slots, for example data attributes or event handlers.
The function receives the slot start and end. Event handlers you return are called in addition to internal handlers:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startScrollTime="07:00:00"
getTimeSlotProps={({ start }) => {
const hour = parseInt(start.split(' ')[1], 10);
if (hour >= 7 && hour < 20) {
return { 'data-business-hours': true };
}
return { 'data-non-business-hours': true };
}}
/>
);
}Overlapping events
Overlapping events are positioned side by side:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
/>
);
}Overlap mode
eventOverlapMode prop controls how overlapping events share the horizontal space:
columns(default) – the width is split evenly, every event is fully visible but narrowcascade– each event is indented and drawn on top of the previous one, use it when many events overlap
import dayjs from 'dayjs';
import { useState } from 'react';
import { SegmentedControl, Stack } from '@mantine/core';
import { ScheduleEventOverlapMode, WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const [mode, setMode] = useState<ScheduleEventOverlapMode>('cascade');
return (
<Stack>
<SegmentedControl
value={mode}
onChange={(value) => setMode(value as ScheduleEventOverlapMode)}
data={[
{ value: 'columns', label: 'columns' },
{ value: 'cascade', label: 'cascade' },
]}
/>
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="14:00:00"
eventOverlapMode={mode}
/>
</Stack>
);
}In cascade mode, a covered event is raised above the others on hover and focus.
Use eventOverlapRaiseDelay prop to change the hover delay in milliseconds:
import { WeekView } from '@mantine/schedule';
function Demo() {
return <WeekView date={new Date()} eventOverlapMode="cascade" eventOverlapRaiseDelay={250} />;
}Drag and drop
Set withEventsDragAndDrop prop to allow dragging events to other days and times.
To reject a drop, for example to prevent double booking, see drop validation:
import dayjs from 'dayjs';
import { useState } from 'react';
import { getStartOfWeek, ScheduleEventData, WeekView } from '@mantine/schedule';
const today = dayjs().format('YYYY-MM-DD');
const tomorrow = dayjs().add(1, 'day').format('YYYY-MM-DD');
const initialEvents: ScheduleEventData[] = [
{
id: 1,
title: 'Morning Standup',
start: `${today} 09:00:00`,
end: `${today} 09:30:00`,
color: 'blue',
},
{
id: 2,
title: 'Team Meeting',
start: `${tomorrow} 11:00:00`,
end: `${tomorrow} 12:00:00`,
color: 'green',
},
{
id: 3,
title: 'Code Review',
start: `${today} 14:00:00`,
end: `${today} 15:00:00`,
color: 'violet',
},
{
id: 4,
title: 'Company Holiday',
start: dayjs(getStartOfWeek({ date: today, firstDayOfWeek: 1 })).format('YYYY-MM-DD HH:mm:ss'),
end: dayjs(getStartOfWeek({ date: today, firstDayOfWeek: 1 }))
.add(2, 'day')
.format('YYYY-MM-DD HH:mm:ss'),
color: 'red',
},
{
id: 5,
title: 'Release Day',
start: dayjs(getStartOfWeek({ date: today, firstDayOfWeek: 1 })).format('YYYY-MM-DD HH:mm:ss'),
end: dayjs(getStartOfWeek({ date: today, firstDayOfWeek: 1 }))
.add(2, 'day')
.format('YYYY-MM-DD HH:mm:ss'),
color: 'orange',
},
];
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const [events, setEvents] = useState(initialEvents);
const handleEventDrop = ({ eventId, newStart, newEnd }: { eventId: string | number; newStart: string; newEnd: string }) => {
setEvents((prev) =>
prev.map((event) =>
event.id === eventId ? { ...event, start: newStart, end: newEnd } : event
)
);
};
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
withEventsDragAndDrop
onEventDrop={handleEventDrop}
/>
);
}Drag interval
Dragged events snap to intervalMinutes by default. Set eventDragInterval to use a different step,
for example to move events in 15-minute increments on a grid with 30-minute slots:
import { useState } from 'react';
import dayjs from 'dayjs';
import { WeekView, ScheduleEventData } from '@mantine/schedule';
const today = dayjs().format('YYYY-MM-DD');
const tomorrow = dayjs().add(1, 'day').format('YYYY-MM-DD');
const initialEvents: ScheduleEventData[] = [
{
id: 1,
title: 'Morning Standup',
start: `${today} 09:00:00`,
end: `${today} 09:30:00`,
color: 'blue',
},
{
id: 2,
title: 'Team Meeting',
start: `${tomorrow} 11:00:00`,
end: `${tomorrow} 12:00:00`,
color: 'green',
},
{
id: 3,
title: 'Code Review',
start: `${today} 14:00:00`,
end: `${today} 15:00:00`,
color: 'violet',
},
];
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const [events, setEvents] = useState(initialEvents);
const handleEventDrop = ({ eventId, newStart, newEnd }: { eventId: string | number; newStart: string; newEnd: string }) => {
setEvents((prev) =>
prev.map((event) =>
event.id === eventId ? { ...event, start: newStart, end: newEnd } : event
)
);
};
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
intervalMinutes={30}
eventDragInterval={15}
withSubHourGridLines={false}
withEventsDragAndDrop
onEventDrop={handleEventDrop}
/>
);
}Restrict draggable events
Return false from canDragEvent to make an event not draggable:
import { useState } from 'react';
import dayjs from 'dayjs';
import { WeekView, ScheduleEventData } from '@mantine/schedule';
const startOfWeek = dayjs().subtract((dayjs().day() + 6) % 7, 'day').format('YYYY-MM-DD');
const dayAfterStartOfWeek = dayjs(startOfWeek).add(1, 'day').format('YYYY-MM-DD');
const initialEvents: ScheduleEventData[] = [
{
id: 1,
title: 'Draggable Event',
start: `${startOfWeek} 09:00:00`,
end: `${startOfWeek} 10:00:00`,
color: 'blue',
},
{
id: 2,
title: 'Locked Event',
start: `${startOfWeek} 11:00:00`,
end: `${startOfWeek} 12:00:00`,
color: 'gray',
payload: { locked: true },
},
{
id: 3,
title: 'Another Draggable',
start: `${dayAfterStartOfWeek} 14:00:00`,
end: `${dayAfterStartOfWeek} 15:00:00`,
color: 'green',
},
];
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const [events, setEvents] = useState(initialEvents);
const handleEventDrop = ({ eventId, newStart, newEnd }: { eventId: string | number; newStart: string; newEnd: string }) => {
setEvents((prev) =>
prev.map((event) =>
event.id === eventId ? { ...event, start: newStart, end: newEnd } : event
)
);
};
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
withEventsDragAndDrop
onEventDrop={handleEventDrop}
canDragEvent={(event) => !event.payload?.locked}
/>
);
}External drag and drop
Use onExternalEventDrop to accept items dragged from outside the schedule.
External items must set data in dataTransfer during their onDragStart.
The callback receives the DataTransfer object and the drop target datetime:
Drag to schedule
Quick Sync
30 min
Workshop
120 min
One-on-One
60 min
import { useRef, useState } from 'react';
import dayjs from 'dayjs';
import { Box, Grid, Text } from '@mantine/core';
import { WeekView, ScheduleEventData } from '@mantine/schedule';
const sidebarItems = [
{ title: 'Quick Sync', duration: 30, color: 'teal' },
{ title: 'Workshop', duration: 120, color: 'orange' },
{ title: 'One-on-One', duration: 60, color: 'violet' },
];
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const [events, setEvents] = useState<ScheduleEventData[]>([]);
const nextId = useRef(1);
const handleExternalDrop = (dataTransfer: DataTransfer, dropDateTime: string) => {
const raw = dataTransfer.getData('text/plain');
if (!raw) {
return;
}
const data = JSON.parse(raw);
const start = dayjs(dropDateTime);
const end = start.add(data.duration, 'minutes');
setEvents((prev) => [
...prev,
{
id: nextId.current++,
title: data.title,
start: start.format('YYYY-MM-DD HH:mm:ss'),
end: end.format('YYYY-MM-DD HH:mm:ss'),
color: data.color,
},
]);
};
const handleEventDrop = ({ eventId, newStart, newEnd }: { eventId: string | number; newStart: string; newEnd: string }) => {
setEvents((prev) =>
prev.map((event) =>
event.id === eventId ? { ...event, start: newStart, end: newEnd } : event
)
);
};
return (
<Grid>
<Grid.Col span={{ base: 12, sm: 3 }}>
<Text fw={500} mb="xs">Drag to schedule</Text>
{sidebarItems.map((item) => (
<Box
key={item.title}
draggable
onDragStart={(e) => {
e.dataTransfer.setData('text/plain', JSON.stringify(item));
e.dataTransfer.effectAllowed = 'copy';
}}
style={{
padding: '8px 12px',
marginBottom: 8,
borderRadius: 4,
cursor: 'grab',
backgroundColor: `var(--mantine-color-${item.color}-light)`,
color: `var(--mantine-color-${item.color}-light-color)`,
}}
>
<Text size="sm" fw={500}>{item.title}</Text>
<Text size="xs">{item.duration} min</Text>
</Box>
))}
</Grid.Col>
<Grid.Col span={{ base: 12, sm: 9 }}>
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
withEventsDragAndDrop
onEventDrop={handleEventDrop}
onExternalEventDrop={handleExternalDrop}
/>
</Grid.Col>
</Grid>
);
}Bidirectional drag and drop
Combine onExternalEventDrop with withEventsDragAndDrop to drag items both to and from
the schedule. A dragged event sets application/json data with { eventId } in dataTransfer,
read it in your drop zone to identify the event:
Unscheduled
Quick Sync
30 min
Workshop
120 min
One-on-One
60 min
import { useRef, useState } from 'react';
import dayjs from 'dayjs';
import { Box, Grid, Text } from '@mantine/core';
import { WeekView, ScheduleEventData } from '@mantine/schedule';
interface SidebarItem {
title: string;
duration: number;
color: string;
}
const initialSidebarItems: SidebarItem[] = [
{ title: 'Quick Sync', duration: 30, color: 'teal' },
{ title: 'Workshop', duration: 120, color: 'orange' },
{ title: 'One-on-One', duration: 60, color: 'violet' },
];
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const [sidebarItems, setSidebarItems] = useState(initialSidebarItems);
const [events, setEvents] = useState<ScheduleEventData[]>([]);
const [sidebarHighlight, setSidebarHighlight] = useState(false);
const nextId = useRef(1);
const handleExternalDrop = (dataTransfer: DataTransfer, dropDateTime: string) => {
const raw = dataTransfer.getData('text/plain');
if (!raw) {
return;
}
const data = JSON.parse(raw);
const start = dayjs(dropDateTime);
const end = start.add(data.duration, 'minutes');
setEvents((prev) => [
...prev,
{
id: nextId.current++,
title: data.title,
start: start.format('YYYY-MM-DD HH:mm:ss'),
end: end.format('YYYY-MM-DD HH:mm:ss'),
color: data.color,
},
]);
setSidebarItems((prev) => prev.filter((item) => item.title !== data.title));
};
const handleEventDrop = ({ eventId, newStart, newEnd }: { eventId: string | number; newStart: string; newEnd: string }) => {
setEvents((prev) =>
prev.map((event) =>
event.id === eventId ? { ...event, start: newStart, end: newEnd } : event
)
);
};
const handleSidebarDrop = (e: React.DragEvent) => {
e.preventDefault();
setSidebarHighlight(false);
const raw = e.dataTransfer.getData('application/json');
if (!raw) {
return;
}
const { eventId } = JSON.parse(raw);
const event = events.find((ev) => String(ev.id) === String(eventId));
if (!event) {
return;
}
const duration = dayjs(event.end).diff(dayjs(event.start), 'minutes');
setSidebarItems((prev) => [
...prev,
{ title: event.title, duration, color: event.color || 'blue' },
]);
setEvents((prev) => prev.filter((ev) => ev.id !== event.id));
};
return (
<Grid>
<Grid.Col span={{ base: 12, sm: 3 }}>
<Box
onDragOver={(e) => {
e.preventDefault();
e.dataTransfer.dropEffect = 'move';
setSidebarHighlight(true);
}}
onDragLeave={() => setSidebarHighlight(false)}
onDrop={handleSidebarDrop}
style={{
padding: 8,
borderRadius: 8,
border: sidebarHighlight
? '2px dashed var(--mantine-color-blue-5)'
: '2px dashed transparent',
transition: 'border-color 150ms',
}}
>
<Text fw={500} mb="xs">Unscheduled</Text>
{sidebarItems.map((item) => (
<Box
key={item.title}
draggable
onDragStart={(e) => {
e.dataTransfer.setData('text/plain', JSON.stringify(item));
e.dataTransfer.effectAllowed = 'copy';
}}
style={{
padding: '8px 12px',
marginBottom: 8,
borderRadius: 4,
cursor: 'grab',
backgroundColor: `var(--mantine-color-${item.color}-light)`,
color: `var(--mantine-color-${item.color}-light-color)`,
}}
>
<Text size="sm" fw={500}>{item.title}</Text>
<Text size="xs">{item.duration} min</Text>
</Box>
))}
{sidebarItems.length === 0 && (
<Text size="xs">Drag events here to unschedule</Text>
)}
</Box>
</Grid.Col>
<Grid.Col span={{ base: 12, sm: 9 }}>
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
withEventsDragAndDrop
onEventDrop={handleEventDrop}
onExternalEventDrop={handleExternalDrop}
/>
</Grid.Col>
</Grid>
);
}Event resize
Set withEventResize prop to allow changing event start and end by dragging its edges,
onEventResize is called with the new range. To reject a resize,
see drop validation:
import { useState } from 'react';
import dayjs from 'dayjs';
import { WeekView, ScheduleEventData } from '@mantine/schedule';
const today = dayjs().format('YYYY-MM-DD');
const tomorrow = dayjs().add(1, 'day').format('YYYY-MM-DD');
const initialEvents: ScheduleEventData[] = [
{
id: 1,
title: 'Morning Standup',
start: `${today} 09:00:00`,
end: `${today} 09:30:00`,
color: 'blue',
},
{
id: 2,
title: 'Team Meeting',
start: `${tomorrow} 11:00:00`,
end: `${tomorrow} 12:00:00`,
color: 'green',
},
{
id: 3,
title: 'Code Review',
start: `${today} 14:00:00`,
end: `${today} 15:00:00`,
color: 'violet',
},
];
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const [events, setEvents] = useState(initialEvents);
const handleEventResize = ({ eventId, newStart, newEnd }: { eventId: string | number; newStart: string; newEnd: string }) => {
setEvents((prev) =>
prev.map((event) =>
event.id === eventId ? { ...event, start: newStart, end: newEnd } : event
)
);
};
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
withEventResize
onEventResize={handleEventResize}
/>
);
}Resize interval
Resized events snap to intervalMinutes by default. Set eventResizeInterval to use a different step,
for example to resize events in 15-minute increments on a grid with 30-minute slots:
import { useState } from 'react';
import dayjs from 'dayjs';
import { WeekView, ScheduleEventData } from '@mantine/schedule';
const today = dayjs().format('YYYY-MM-DD');
const tomorrow = dayjs().add(1, 'day').format('YYYY-MM-DD');
const initialEvents: ScheduleEventData[] = [
{
id: 1,
title: 'Morning Standup',
start: `${today} 09:00:00`,
end: `${today} 09:30:00`,
color: 'blue',
},
{
id: 2,
title: 'Team Meeting',
start: `${tomorrow} 11:00:00`,
end: `${tomorrow} 12:00:00`,
color: 'green',
},
{
id: 3,
title: 'Code Review',
start: `${today} 14:00:00`,
end: `${today} 15:00:00`,
color: 'violet',
},
];
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const [events, setEvents] = useState(initialEvents);
const handleEventResize = ({ eventId, newStart, newEnd }: { eventId: string | number; newStart: string; newEnd: string }) => {
setEvents((prev) =>
prev.map((event) =>
event.id === eventId ? { ...event, start: newStart, end: newEnd } : event
)
);
};
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
intervalMinutes={30}
eventResizeInterval={15}
withSubHourGridLines={false}
withEventResize
onEventResize={handleEventResize}
/>
);
}Restrict resizable events
Return false from canResizeEvent to make an event not resizable:
import { useState } from 'react';
import dayjs from 'dayjs';
import { WeekView, ScheduleEventData } from '@mantine/schedule';
const startOfWeek = dayjs().subtract((dayjs().day() + 6) % 7, 'day').format('YYYY-MM-DD');
const dayAfterStartOfWeek = dayjs(startOfWeek).add(1, 'day').format('YYYY-MM-DD');
const initialEvents: ScheduleEventData[] = [
{
id: 1,
title: 'Resizable Event',
start: `${startOfWeek} 09:00:00`,
end: `${startOfWeek} 10:00:00`,
color: 'blue',
},
{
id: 2,
title: 'Locked Event',
start: `${startOfWeek} 11:00:00`,
end: `${startOfWeek} 12:00:00`,
color: 'gray',
payload: { locked: true },
},
{
id: 3,
title: 'Another Resizable',
start: `${dayAfterStartOfWeek} 14:00:00`,
end: `${dayAfterStartOfWeek} 15:00:00`,
color: 'green',
},
];
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const [events, setEvents] = useState(initialEvents);
const handleEventResize = ({ eventId, newStart, newEnd }: { eventId: string | number; newStart: string; newEnd: string }) => {
setEvents((prev) =>
prev.map((event) =>
event.id === eventId ? { ...event, start: newStart, end: newEnd } : event
)
);
};
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
withEventResize
onEventResize={handleEventResize}
canResizeEvent={(event) => !event.payload?.locked}
/>
);
}Full event customization
Use renderEvent prop to replace the event element. The function receives the event and the props
of the root element, including children. Use it to wrap events in HoverCard, Tooltip or other components:
import dayjs from 'dayjs';
import { useState } from 'react';
import { HoverCard, UnstyledButton } from '@mantine/core';
import { WeekView, ScheduleEventData } from '@mantine/schedule';
import { EventDetails } from './EventDetails';
import { eventsData } from './events';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const [events, setEvents] = useState<ScheduleEventData[]>(eventsData);
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
withEventsDragAndDrop
onEventDrop={({ eventId, newStart, newEnd }) => {
setEvents((current) =>
current.map((event) =>
event.id === eventId
? {
...event,
start: dayjs(newStart).format('YYYY-MM-DD HH:mm:ss'),
end: dayjs(newEnd).format('YYYY-MM-DD HH:mm:ss'),
}
: event
)
);
}}
renderEvent={(event, props) => (
<HoverCard width={280} position="right" closeDelay={0} transitionProps={{ duration: 0 }}>
<HoverCard.Target>
<UnstyledButton {...props} />
</HoverCard.Target>
<HoverCard.Dropdown>
<EventDetails event={event} />
</HoverCard.Dropdown>
</HoverCard>
)}
/>
);
}Custom event body
Use renderEventBody prop to change the content inside events without replacing the event element:
import dayjs from 'dayjs';
import { useState } from 'react';
import { ClockIcon, MapPinIcon } from '@phosphor-icons/react';
import { Group, Text } from '@mantine/core';
import { WeekView, ScheduleEventData } from '@mantine/schedule';
const startOfWeek = dayjs().subtract((dayjs().day() + 6) % 7, 'day').format('YYYY-MM-DD');
const dayAfterStartOfWeek = dayjs(startOfWeek).add(1, 'day').format('YYYY-MM-DD');
const events: ScheduleEventData[] = [
{
id: 1,
title: 'Morning Standup',
start: `${startOfWeek} 09:00:00`,
end: `${startOfWeek} 09:30:00`,
color: 'blue',
payload: { location: 'Room A' },
},
{
id: 2,
title: 'Client Meeting',
start: `${startOfWeek} 11:00:00`,
end: `${startOfWeek} 12:00:00`,
color: 'green',
payload: { location: 'Video Call' },
},
{
id: 3,
title: 'Lunch Break',
start: `${dayAfterStartOfWeek} 12:30:00`,
end: `${dayAfterStartOfWeek} 13:30:00`,
color: 'orange',
payload: { location: 'Cafeteria' },
},
];
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
renderEventBody={(event) => (
<Group>
<Text fz={12} fw={500}>
{event.title}
</Text>
<Group gap={4}>
<ClockIcon size={12} />
<Text fz={10} lh={1}>
{dayjs(event.start).format('h:mm A')}
</Text>
</Group>
{event.payload?.location && (
<Group gap={4}>
<MapPinIcon size={12} />
<Text fz={10}>{event.payload.location}</Text>
</Group>
)}
</Group>
)}
/>
);
}Recurring events
Recurring events are expanded for the visible week, see recurring events guide:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView, getStartOfWeek } from '@mantine/schedule';
const weekStart = dayjs(getStartOfWeek({ date: new Date(), firstDayOfWeek: 1 })).format('YYYY-MM-DD');
const events = [
{
id: 'weekly-sync-series',
title: 'Weekly sync (series)',
start: `${weekStart} 10:00:00`,
end: `${weekStart} 11:00:00`,
color: 'blue',
recurrence: {
rrule: 'FREQ=WEEKLY;BYDAY=MO,WE;COUNT=12',
exdate: [`${dayjs(weekStart).add(2, 'day').format('YYYY-MM-DD')} 10:00:00`],
},
},
{
id: 'weekly-sync-override',
title: 'Weekly sync (moved this week)',
start: `${dayjs(weekStart).add(2, 'day').format('YYYY-MM-DD')} 15:00:00`,
end: `${dayjs(weekStart).add(2, 'day').format('YYYY-MM-DD')} 16:00:00`,
color: 'grape',
recurringEventId: 'weekly-sync-series',
recurrenceId: `${dayjs(weekStart).add(2, 'day').format('YYYY-MM-DD')} 10:00:00`,
},
];
function Demo() {
const [date, setDate] = useState(weekStart);
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="20:00:00"
intervalMinutes={60}
/>
);
}Background events
Set display="background" on an event to render it as a block behind regular events,
for example to mark unavailability or breaks. Background events cannot be clicked, dragged or resized by default:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView, ScheduleEventData } from '@mantine/schedule';
const today = dayjs().format('YYYY-MM-DD');
const events: ScheduleEventData[] = [
{
id: 'lunch-block',
title: 'Lunch break',
start: `${today} 12:00:00`,
end: `${today} 13:00:00`,
color: 'gray',
display: 'background',
},
{
id: 'focus-time',
title: 'Focus time',
start: `${today} 14:00:00`,
end: `${today} 16:00:00`,
color: 'blue',
display: 'background',
},
{
id: 'team-meeting',
title: 'Team meeting',
start: `${today} 10:00:00`,
end: `${today} 11:00:00`,
color: 'violet',
},
{
id: 'code-review',
title: 'Code review',
start: `${today} 14:30:00`,
end: `${today} 15:30:00`,
color: 'green',
},
];
function Demo() {
const [date, setDate] = useState(today);
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
/>
);
}Interactive background events
Set withInteractiveBackgroundEvents prop to make background events clickable. onEventClick
is called with the background event, check event.display === 'background' to tell it apart.
An interactive background event covers the time slots underneath it, clicks in its range go to the event:
Last clicked: nothing yet
import dayjs from 'dayjs';
import { useState } from 'react';
import { Text } from '@mantine/core';
import { ScheduleEventData, WeekView } from '@mantine/schedule';
const today = dayjs().format('YYYY-MM-DD');
const tomorrow = dayjs().add(1, 'day').format('YYYY-MM-DD');
const events: ScheduleEventData[] = [
{
id: 'out-of-office',
title: 'Out of office',
start: `${today} 12:00:00`,
end: `${today} 16:00:00`,
color: 'red',
display: 'background',
},
{
id: 'standup',
title: 'Standup',
start: `${today} 09:30:00`,
end: `${today} 10:00:00`,
color: 'teal',
},
{
id: 'team-meeting',
title: 'Team meeting',
start: `${today} 13:00:00`,
end: `${today} 14:00:00`,
color: 'violet',
},
{
id: 'design-review',
title: 'Design review',
start: `${today} 14:30:00`,
end: `${today} 15:30:00`,
color: 'blue',
},
{
id: 'retrospective',
title: 'Retrospective',
start: `${tomorrow} 13:00:00`,
end: `${tomorrow} 14:00:00`,
color: 'grape',
},
];
function Demo() {
const [date, setDate] = useState(today);
const [clicked, setClicked] = useState<ScheduleEventData | null>(null);
return (
<>
<Text size="sm" mb="md">
Last clicked:{' '}
{clicked
? `${clicked.title} (${clicked.display === 'background' ? 'background' : 'regular'} event)`
: 'nothing yet'}
</Text>
<WeekView
date={date}
onDateChange={setDate}
events={events}
withInteractiveBackgroundEvents
onEventClick={setClicked}
startTime="08:00:00"
endTime="18:00:00"
/>
</>
);
}Resizable background events
Set withEventResize together with withInteractiveBackgroundEvents to make background events resizable.
All-day background events are never resizable. To keep background events fixed while
regular events stay resizable, return false from canResizeEvent:
<WeekView
withEventResize
withInteractiveBackgroundEvents
canResizeEvent={(event) => event.display !== 'background'}
/>Custom background event styles with drag and drop blocking
Use Styles API to change background events appearance. The example below displays blocked time with diagonal lines and rejects drops that overlap background events:
import dayjs from 'dayjs';
import { useState } from 'react';
import { getStartOfWeek, ScheduleEventData, WeekView } from '@mantine/schedule';
import classes from './Demo.module.css';
const weekStart = dayjs(
getStartOfWeek({ date: new Date(), firstDayOfWeek: 1 })
);
const weekdays = Array.from({ length: 5 }, (_, i) =>
weekStart.add(i, 'day').format('YYYY-MM-DD')
);
const initialEvents: ScheduleEventData[] = [
...weekdays.map((day, i) => ({
id: `lunch-${i}`,
title: 'Lunch break',
start: `${day} 12:00:00`,
end: `${day} 13:00:00`,
color: 'red',
display: 'background' as const,
})),
{
id: 'team-meeting',
title: 'Team meeting',
start: `${weekdays[0]} 10:00:00`,
end: `${weekdays[0]} 11:00:00`,
color: 'violet',
},
{
id: 'code-review',
title: 'Code review',
start: `${weekdays[2]} 15:00:00`,
end: `${weekdays[2]} 16:00:00`,
color: 'green',
},
];
function overlapsBackground(
newStart: string,
newEnd: string,
events: ScheduleEventData[]
) {
return events.some(
(e) =>
e.display === 'background' && newStart < e.end && newEnd > e.start
);
}
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const [events, setEvents] = useState(initialEvents);
const handleEventDrop = ({
eventId,
newStart,
newEnd,
}: {
eventId: string | number;
newStart: string;
newEnd: string;
}) => {
setEvents((prev) =>
prev.map((event) =>
event.id === eventId
? { ...event, start: newStart, end: newEnd }
: event
)
);
};
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
withEventsDragAndDrop
canDropEvent={({ start, end }) => !overlapsBackground(start, end, events)}
onEventDrop={handleEventDrop}
classNames={{ weekViewBackgroundEvent: classes.backgroundEvent }}
/>
);
}Agenda view
Set withAgenda prop to add an "Agenda" button to the header. It opens an AgendaView
with events of the current week as a list:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
const today = dayjs().format('YYYY-MM-DD');
const startOfWeek = dayjs().startOf('week').add(1, 'day').format('YYYY-MM-DD');
const events = [
{
id: 'standup',
title: 'Morning Standup',
start: `${today} 09:00:00`,
end: `${today} 09:30:00`,
color: 'blue',
},
{
id: 'team-meeting',
title: 'Team Meeting',
start: `${today} 10:00:00`,
end: `${today} 11:30:00`,
color: 'green',
},
{
id: 'weekly-review-series',
title: 'Weekly review',
start: `${startOfWeek} 16:00:00`,
end: `${startOfWeek} 17:00:00`,
color: 'orange',
recurrence: {
rrule: 'FREQ=WEEKLY;COUNT=8',
},
},
];
function Demo() {
const [date, setDate] = useState(today);
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
withAgenda
/>
);
}Static mode
Set mode="static" to disable interactions with events and time slots. Header navigation still works:
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
mode="static"
/>
);
}Localization
Use locale prop to set the dayjs locale for date formatting.
Combine it with labels prop to translate all UI text:
import 'dayjs/locale/es';
import dayjs from 'dayjs';
import { useState } from 'react';
import { WeekView } from '@mantine/schedule';
import { events } from './data';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
return (
<WeekView
date={date}
onDateChange={setDate}
events={events}
startTime="08:00:00"
endTime="18:00:00"
locale="es"
labels={{
day: 'Día',
week: 'Semana',
month: 'Mes',
year: 'Año',
today: 'Hoy',
previous: 'Anterior',
next: 'Siguiente',
selectMonth: 'Seleccionar mes',
selectYear: 'Seleccionar año',
switchToDayView: 'Cambiar a vista de día',
switchToWeekView: 'Cambiar a vista de semana',
switchToMonthView: 'Cambiar a vista de mes',
switchToYearView: 'Cambiar a vista de año',
viewSelectLabel: 'Vista del calendario',
allDay: 'Todo el día',
weekday: 'Día de la semana',
timeSlot: 'Franja horaria',
weekNumber: (weekNumber) => `Semana ${weekNumber}`,
moreLabel: (hiddenEventsCount) => `+${hiddenEventsCount} más`,
}}
/>
);
}Create and update events
Set withDragSlotSelect prop to allow selecting a time range by dragging across time slots of one day.
onSlotDragEnd is called with the range start and end when the drag ends.
Combine it with slot and event click callbacks to create and edit events:
import dayjs from 'dayjs';
import { useState } from 'react';
import { ScheduleEventData, WeekView } from '@mantine/schedule';
import { EventData, EventForm } from './EventForm';
import { events } from './events';
function Demo() {
const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
const [allEvents, setAllEvents] = useState<ScheduleEventData[]>(events);
const [formOpened, setFormOpened] = useState(false);
const [selectedEventData, setSelectedEventData] = useState<EventData | null>(null);
const handleTimeSlotClick = ({ slotStart, slotEnd }: { slotStart: string; slotEnd: string }) => {
setSelectedEventData({
title: '',
start: new Date(slotStart),
end: new Date(slotEnd),
color: 'blue',
});
setFormOpened(true);
};
const handleAllDaySlotClick = (slotDate: string) => {
setSelectedEventData({
title: '',
start: dayjs(slotDate).startOf('day').toDate(),
end: dayjs(slotDate).startOf('day').add(1, 'day').toDate(),
color: 'blue',
});
setFormOpened(true);
};
const handleEventClick = (event: ScheduleEventData) => {
setSelectedEventData({
id: event.id,
title: event.title,
start: new Date(event.start),
end: new Date(event.end),
color: event.color || 'blue',
});
setFormOpened(true);
};
const handleSubmit = (values: EventData) => {
if (values.id) {
setAllEvents((prev) =>
prev.map((event) =>
event.id === values.id
? {
...event,
title: values.title,
start: dayjs(values.start).toISOString(),
end: dayjs(values.end).toISOString(),
color: values.color || 'blue',
}
: event
)
);
} else {
setAllEvents((prev) => [
...prev,
{
id: Math.random().toString(36).substring(2, 11),
title: values.title,
start: dayjs(values.start).toISOString(),
end: dayjs(values.end).toISOString(),
color: values.color || 'blue',
},
]);
}
};
const handleDeleteEvent = () => {
if (selectedEventData?.id) {
setAllEvents((prev) => prev.filter((e) => e.id !== selectedEventData.id));
}
};
const handleSlotDragEnd = (rangeStart: string, rangeEnd: string) => {
setSelectedEventData({
title: '',
start: new Date(rangeStart),
end: new Date(rangeEnd),
color: 'blue',
});
setFormOpened(true);
};
return (
<>
<WeekView
date={date}
onDateChange={setDate}
events={allEvents}
withDragSlotSelect
onTimeSlotClick={handleTimeSlotClick}
onAllDaySlotClick={handleAllDaySlotClick}
onSlotDragEnd={handleSlotDragEnd}
onEventClick={handleEventClick}
startTime="08:00:00"
endTime="18:00:00"
/>
<EventForm
opened={formOpened}
onClose={() => setFormOpened(false)}
onExitTransitionEnd={() => setSelectedEventData(null)}
values={selectedEventData}
onSubmit={handleSubmit}
onDelete={selectedEventData?.id ? handleDeleteEvent : undefined}
/>
</>
);
}Responsive styles
WeekView uses container queries for responsive styles. Labels are hidden and paddings are reduced when the container is narrow.
Accessibility
Focus management
The weekdays row, the all-day row and the time slots grid each have only their first element in the tab order, other elements are reached with arrow keys.
Keyboard interactions
Weekdays row:
| Key | Description |
|---|---|
| ArrowRight | Focuses next weekday |
| ArrowLeft | Focuses previous weekday |
All-day slots (when enabled):
| Key | Description |
|---|---|
| ArrowRight | Focuses next all-day slot |
| ArrowLeft | Focuses previous all-day slot |
| ArrowDown | Focuses first time slot of the same day |
Time slots:
| Key | Description |
|---|---|
| ArrowRight | Focuses same time slot in the next day |
| ArrowLeft | Focuses same time slot in the previous day |
| ArrowDown | Focuses next time slot in the same day |
| ArrowUp | Focuses previous time slot (or all-day slot if on first time slot and all-day slots are enabled) |
Slot labels
Each time slot button has an aria-label with its date and time range, for example "Time slot 2025-11-03 08:00:00 - 09:00:00".
All-day slots are labeled "All day 2025-11-03".
Weekday buttons use their visible text as their accessible name, for example "Mon 3".