@umituz/web-dashboard 11.10.1 → 11.12.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +5 -1
- package/src/domains/calendar/calendar.css +191 -0
- package/src/domains/calendar/components/CalendarPage.test.tsx +178 -0
- package/src/domains/calendar/components/CalendarPage.tsx +296 -0
- package/src/domains/calendar/components/CalendarSelectedDayPanel.tsx +136 -0
- package/src/domains/calendar/components/index.ts +5 -0
- package/src/domains/calendar/types/calendar-page.types.ts +91 -0
- package/src/domains/calendar/types/index.ts +1 -0
- package/src/domains/kanban/components/KanbanBoard.test.tsx +226 -0
- package/src/domains/kanban/components/KanbanBoard.tsx +135 -0
- package/src/domains/kanban/components/KanbanCard.tsx +160 -0
- package/src/domains/kanban/components/KanbanColumn.tsx +163 -0
- package/src/domains/kanban/components/KanbanPage.test.tsx +115 -0
- package/src/domains/kanban/components/KanbanPage.tsx +91 -0
- package/src/domains/kanban/components/index.ts +4 -0
- package/src/domains/kanban/index.ts +12 -0
- package/src/domains/kanban/kanban.css +406 -0
- package/src/domains/kanban/types.ts +103 -0
- package/src/domains/layouts/components/DashboardLayout.tsx +6 -1
- package/src/index.ts +1 -0
- package/src/styles/chrome.css +4 -0
- package/src/styles/dashboard.css +2 -0
|
@@ -0,0 +1,136 @@
|
|
|
1
|
+
import type { ReactNode } from 'react';
|
|
2
|
+
import { Badge, Button } from '@umituz/web-design-system/atoms';
|
|
3
|
+
import { formatDate } from '@umituz/web-design-system/utils';
|
|
4
|
+
import type {
|
|
5
|
+
CalendarPageItem,
|
|
6
|
+
CalendarPageLabels,
|
|
7
|
+
CalendarSelectedDayConfig,
|
|
8
|
+
} from '../types';
|
|
9
|
+
|
|
10
|
+
const formatTime = (minutes?: number): string => {
|
|
11
|
+
if (minutes === undefined || minutes === null) return '';
|
|
12
|
+
const h = Math.floor(minutes / 60);
|
|
13
|
+
const m = minutes % 60;
|
|
14
|
+
return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`;
|
|
15
|
+
};
|
|
16
|
+
|
|
17
|
+
export interface CalendarSelectedDayPanelProps<T = unknown> {
|
|
18
|
+
config: CalendarSelectedDayConfig<T>;
|
|
19
|
+
dayKey: string;
|
|
20
|
+
items: readonly CalendarPageItem<T>[];
|
|
21
|
+
labels?: CalendarPageLabels;
|
|
22
|
+
onSelectItem?: (item: CalendarPageItem<T>) => void;
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
export function CalendarSelectedDayPanel<T = unknown>({
|
|
26
|
+
config,
|
|
27
|
+
dayKey,
|
|
28
|
+
items,
|
|
29
|
+
labels,
|
|
30
|
+
onSelectItem,
|
|
31
|
+
}: CalendarSelectedDayPanelProps<T>): ReactNode {
|
|
32
|
+
return (
|
|
33
|
+
<section
|
|
34
|
+
className="udb-cal-selected-card"
|
|
35
|
+
data-testid="calendar-selected-day-panel"
|
|
36
|
+
aria-label="Selected day events"
|
|
37
|
+
>
|
|
38
|
+
<header className="udb-cal-selected-header">
|
|
39
|
+
<div className="udb-cal-selected-header-left">
|
|
40
|
+
<span className="udb-cal-selected-eyebrow">
|
|
41
|
+
{labels?.selectedDay ?? 'Selected Day'}
|
|
42
|
+
</span>
|
|
43
|
+
<span className="udb-cal-selected-title">
|
|
44
|
+
{config.title ? config.title(dayKey) : formatDate(dayKey, 'medium')}
|
|
45
|
+
</span>
|
|
46
|
+
<span className="udb-cal-count">
|
|
47
|
+
{labels?.eventsCount ? labels.eventsCount(items.length) : items.length}
|
|
48
|
+
</span>
|
|
49
|
+
</div>
|
|
50
|
+
{config.action && (
|
|
51
|
+
<Button
|
|
52
|
+
size="sm"
|
|
53
|
+
variant="outline"
|
|
54
|
+
onClick={() => config.action!.onClick(dayKey)}
|
|
55
|
+
>
|
|
56
|
+
{config.action.label}
|
|
57
|
+
</Button>
|
|
58
|
+
)}
|
|
59
|
+
</header>
|
|
60
|
+
|
|
61
|
+
{items.length === 0 ? (
|
|
62
|
+
config.renderEmpty ? (
|
|
63
|
+
config.renderEmpty(dayKey)
|
|
64
|
+
) : (
|
|
65
|
+
<div className="udb-cal-empty">
|
|
66
|
+
{config.emptyText ??
|
|
67
|
+
labels?.noEvents ??
|
|
68
|
+
'No events scheduled for this day'}
|
|
69
|
+
</div>
|
|
70
|
+
)
|
|
71
|
+
) : (
|
|
72
|
+
<ul className="udb-cal-feed-list">
|
|
73
|
+
{items.map((item) => (
|
|
74
|
+
<li key={item.id}>
|
|
75
|
+
{config.renderItem ? (
|
|
76
|
+
config.renderItem(item)
|
|
77
|
+
) : onSelectItem ? (
|
|
78
|
+
<button
|
|
79
|
+
type="button"
|
|
80
|
+
onClick={() => onSelectItem(item)}
|
|
81
|
+
className={`udb-cal-feed-item udb-cal-feed-btn${item.muted ? ' is-muted' : ''}`}
|
|
82
|
+
>
|
|
83
|
+
<span
|
|
84
|
+
className={`ds-cal-legend-dot ds-cal-dot--${item.tone ?? 'primary'}`}
|
|
85
|
+
aria-hidden
|
|
86
|
+
/>
|
|
87
|
+
<span className="udb-cal-feed-body">
|
|
88
|
+
<span className="udb-cal-feed-title">{item.title}</span>
|
|
89
|
+
{item.meta && (
|
|
90
|
+
<span className="udb-cal-feed-meta">{item.meta}</span>
|
|
91
|
+
)}
|
|
92
|
+
</span>
|
|
93
|
+
<span className="udb-cal-feed-end">
|
|
94
|
+
{item.startMin !== undefined && (
|
|
95
|
+
<span>
|
|
96
|
+
{item.endMin !== undefined
|
|
97
|
+
? `${formatTime(item.startMin)} - ${formatTime(item.endMin)}`
|
|
98
|
+
: formatTime(item.startMin)}
|
|
99
|
+
</span>
|
|
100
|
+
)}
|
|
101
|
+
{item.kind && <Badge variant="neutral">{item.kind}</Badge>}
|
|
102
|
+
</span>
|
|
103
|
+
</button>
|
|
104
|
+
) : (
|
|
105
|
+
<div
|
|
106
|
+
className={`udb-cal-feed-item${item.muted ? ' is-muted' : ''}`}
|
|
107
|
+
>
|
|
108
|
+
<span
|
|
109
|
+
className={`ds-cal-legend-dot ds-cal-dot--${item.tone ?? 'primary'}`}
|
|
110
|
+
aria-hidden
|
|
111
|
+
/>
|
|
112
|
+
<div className="udb-cal-feed-body">
|
|
113
|
+
<div className="udb-cal-feed-title">{item.title}</div>
|
|
114
|
+
{item.meta && (
|
|
115
|
+
<div className="udb-cal-feed-meta">{item.meta}</div>
|
|
116
|
+
)}
|
|
117
|
+
</div>
|
|
118
|
+
<div className="udb-cal-feed-end">
|
|
119
|
+
{item.startMin !== undefined && (
|
|
120
|
+
<span>
|
|
121
|
+
{item.endMin !== undefined
|
|
122
|
+
? `${formatTime(item.startMin)} - ${formatTime(item.endMin)}`
|
|
123
|
+
: formatTime(item.startMin)}
|
|
124
|
+
</span>
|
|
125
|
+
)}
|
|
126
|
+
{item.kind && <Badge variant="neutral">{item.kind}</Badge>}
|
|
127
|
+
</div>
|
|
128
|
+
</div>
|
|
129
|
+
)}
|
|
130
|
+
</li>
|
|
131
|
+
))}
|
|
132
|
+
</ul>
|
|
133
|
+
)}
|
|
134
|
+
</section>
|
|
135
|
+
);
|
|
136
|
+
}
|
|
@@ -13,3 +13,8 @@ export type {
|
|
|
13
13
|
CalendarResource,
|
|
14
14
|
CalendarResourceTimelineProps,
|
|
15
15
|
} from '@umituz/web-design-system/organisms';
|
|
16
|
+
export { CalendarPage } from './CalendarPage';
|
|
17
|
+
export {
|
|
18
|
+
CalendarSelectedDayPanel,
|
|
19
|
+
type CalendarSelectedDayPanelProps,
|
|
20
|
+
} from './CalendarSelectedDayPanel';
|
|
@@ -0,0 +1,91 @@
|
|
|
1
|
+
import type { ReactNode } from 'react';
|
|
2
|
+
import type {
|
|
3
|
+
CalendarItem,
|
|
4
|
+
CalendarLabels,
|
|
5
|
+
CalendarScreenView,
|
|
6
|
+
CalendarTone,
|
|
7
|
+
} from '@umituz/web-design-system/organisms';
|
|
8
|
+
|
|
9
|
+
export type CalendarPageItem<T = unknown> = CalendarItem & {
|
|
10
|
+
category?: string;
|
|
11
|
+
payload?: T;
|
|
12
|
+
};
|
|
13
|
+
|
|
14
|
+
export interface CalendarCategory {
|
|
15
|
+
id: string;
|
|
16
|
+
label: string;
|
|
17
|
+
tone?: CalendarTone;
|
|
18
|
+
icon?: ReactNode;
|
|
19
|
+
match?: (item: CalendarItem) => boolean;
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
export interface CalendarPageAction {
|
|
23
|
+
label: string;
|
|
24
|
+
onClick: () => void;
|
|
25
|
+
icon?: ReactNode;
|
|
26
|
+
variant?: 'primary' | 'secondary' | 'outline' | 'ghost' | 'danger';
|
|
27
|
+
disabled?: boolean;
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
export interface CalendarSelectedDayConfig<T = unknown> {
|
|
31
|
+
title?: (dayKey: string) => ReactNode;
|
|
32
|
+
renderItem?: (item: CalendarPageItem<T>) => ReactNode;
|
|
33
|
+
renderEmpty?: (dayKey: string) => ReactNode;
|
|
34
|
+
emptyText?: string;
|
|
35
|
+
action?: {
|
|
36
|
+
label: string;
|
|
37
|
+
onClick: (dayKey: string) => void;
|
|
38
|
+
};
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
export interface CalendarPageLabels extends Partial<CalendarLabels> {
|
|
42
|
+
allCategories?: string;
|
|
43
|
+
selectedDay?: string;
|
|
44
|
+
noEvents?: string;
|
|
45
|
+
eventsCount?: (count: number) => string;
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
export interface CalendarPageProps<T = unknown> {
|
|
49
|
+
title: string;
|
|
50
|
+
subtitle?: string;
|
|
51
|
+
kicker?: ReactNode;
|
|
52
|
+
actions?: ReactNode | CalendarPageAction | readonly CalendarPageAction[];
|
|
53
|
+
callout?: ReactNode;
|
|
54
|
+
|
|
55
|
+
items: readonly CalendarPageItem<T>[];
|
|
56
|
+
categories?: readonly CalendarCategory[];
|
|
57
|
+
categoryMode?: 'single' | 'multiple';
|
|
58
|
+
activeCategoryIds?: readonly string[];
|
|
59
|
+
onActiveCategoriesChange?: (categoryIds: string[]) => void;
|
|
60
|
+
|
|
61
|
+
views?: readonly CalendarScreenView[];
|
|
62
|
+
defaultView?: CalendarScreenView;
|
|
63
|
+
view?: CalendarScreenView;
|
|
64
|
+
onViewChange?: (view: CalendarScreenView) => void;
|
|
65
|
+
|
|
66
|
+
cursor?: string;
|
|
67
|
+
initialCursor?: string;
|
|
68
|
+
onCursorChange?: (dayKey: string) => void;
|
|
69
|
+
|
|
70
|
+
selectedDay?: string | null;
|
|
71
|
+
initialSelectedDay?: string | null;
|
|
72
|
+
onSelectDay?: (dayKey: string) => void;
|
|
73
|
+
selectedDayDetail?: CalendarSelectedDayConfig<T> | boolean;
|
|
74
|
+
|
|
75
|
+
onSelectItem?: (item: CalendarPageItem<T>) => void;
|
|
76
|
+
onSlotClick?: (dayKey: string, minutes: number) => void;
|
|
77
|
+
|
|
78
|
+
weekStartsOn?: 0 | 1;
|
|
79
|
+
dayStartMin?: number;
|
|
80
|
+
dayEndMin?: number;
|
|
81
|
+
maxPerDay?: number;
|
|
82
|
+
agendaDays?: number;
|
|
83
|
+
|
|
84
|
+
locale?: string;
|
|
85
|
+
labels?: CalendarPageLabels;
|
|
86
|
+
|
|
87
|
+
toolbarExtra?: ReactNode;
|
|
88
|
+
footer?: ReactNode;
|
|
89
|
+
children?: ReactNode;
|
|
90
|
+
className?: string;
|
|
91
|
+
}
|
|
@@ -0,0 +1,226 @@
|
|
|
1
|
+
import { describe, expect, it, vi } from 'vitest';
|
|
2
|
+
import { render, screen, fireEvent } from '@testing-library/react';
|
|
3
|
+
import { KanbanBoard } from './KanbanBoard';
|
|
4
|
+
import type { KanbanColumn, KanbanItem } from '../types';
|
|
5
|
+
|
|
6
|
+
interface TaskPayload {
|
|
7
|
+
priority: 'low' | 'medium' | 'high';
|
|
8
|
+
}
|
|
9
|
+
|
|
10
|
+
const COLUMNS: readonly KanbanColumn<TaskPayload>[] = [
|
|
11
|
+
{ id: 'todo', title: 'To Do', tone: 'neutral' },
|
|
12
|
+
{ id: 'in_progress', title: 'In Progress', tone: 'primary', limit: 2 },
|
|
13
|
+
{ id: 'done', title: 'Done', tone: 'success' },
|
|
14
|
+
];
|
|
15
|
+
|
|
16
|
+
const ITEMS: readonly KanbanItem<TaskPayload>[] = [
|
|
17
|
+
{
|
|
18
|
+
id: 'task-1',
|
|
19
|
+
columnId: 'todo',
|
|
20
|
+
title: 'Prepare blueprints',
|
|
21
|
+
description: 'Review structural schematics',
|
|
22
|
+
tone: 'info',
|
|
23
|
+
tags: [{ label: 'Arch' }],
|
|
24
|
+
assignee: { name: 'Alice Smith', initials: 'AS' },
|
|
25
|
+
meta: 'Due tomorrow',
|
|
26
|
+
payload: { priority: 'high' },
|
|
27
|
+
},
|
|
28
|
+
{
|
|
29
|
+
id: 'task-2',
|
|
30
|
+
columnId: 'in_progress',
|
|
31
|
+
title: 'Site excavation',
|
|
32
|
+
tone: 'warning',
|
|
33
|
+
payload: { priority: 'medium' },
|
|
34
|
+
},
|
|
35
|
+
];
|
|
36
|
+
|
|
37
|
+
describe('KanbanBoard', () => {
|
|
38
|
+
it('renders all columns with titles and counts', () => {
|
|
39
|
+
render(<KanbanBoard<TaskPayload> columns={COLUMNS} items={ITEMS} />);
|
|
40
|
+
|
|
41
|
+
expect(screen.getByText('To Do')).toBeDefined();
|
|
42
|
+
expect(screen.getByText('In Progress')).toBeDefined();
|
|
43
|
+
expect(screen.getByText('Done')).toBeDefined();
|
|
44
|
+
|
|
45
|
+
expect(screen.getByText('Prepare blueprints')).toBeDefined();
|
|
46
|
+
expect(screen.getByText('Site excavation')).toBeDefined();
|
|
47
|
+
});
|
|
48
|
+
|
|
49
|
+
it('renders empty column indicator for columns without items', () => {
|
|
50
|
+
render(
|
|
51
|
+
<KanbanBoard<TaskPayload>
|
|
52
|
+
columns={COLUMNS}
|
|
53
|
+
items={ITEMS}
|
|
54
|
+
emptyText="No tasks here"
|
|
55
|
+
/>,
|
|
56
|
+
);
|
|
57
|
+
|
|
58
|
+
expect(screen.getByText('No tasks here')).toBeDefined();
|
|
59
|
+
});
|
|
60
|
+
|
|
61
|
+
it('fires onSelectItem when clicking a card', () => {
|
|
62
|
+
const handleSelect = vi.fn();
|
|
63
|
+
render(
|
|
64
|
+
<KanbanBoard<TaskPayload>
|
|
65
|
+
columns={COLUMNS}
|
|
66
|
+
items={ITEMS}
|
|
67
|
+
onSelectItem={handleSelect}
|
|
68
|
+
/>,
|
|
69
|
+
);
|
|
70
|
+
|
|
71
|
+
fireEvent.click(screen.getByText('Prepare blueprints'));
|
|
72
|
+
expect(handleSelect).toHaveBeenCalledWith(ITEMS[0]);
|
|
73
|
+
});
|
|
74
|
+
|
|
75
|
+
it('fires onSelectItem on Enter key press', () => {
|
|
76
|
+
const handleSelect = vi.fn();
|
|
77
|
+
render(
|
|
78
|
+
<KanbanBoard<TaskPayload>
|
|
79
|
+
columns={COLUMNS}
|
|
80
|
+
items={ITEMS}
|
|
81
|
+
onSelectItem={handleSelect}
|
|
82
|
+
/>,
|
|
83
|
+
);
|
|
84
|
+
|
|
85
|
+
const card = screen.getByText('Prepare blueprints').closest('.udb-kanban-card');
|
|
86
|
+
expect(card).toBeTruthy();
|
|
87
|
+
if (card) {
|
|
88
|
+
fireEvent.keyDown(card, { key: 'Enter' });
|
|
89
|
+
expect(handleSelect).toHaveBeenCalledWith(ITEMS[0]);
|
|
90
|
+
}
|
|
91
|
+
});
|
|
92
|
+
|
|
93
|
+
it('moves item forward via stage button', () => {
|
|
94
|
+
const handleMove = vi.fn();
|
|
95
|
+
render(
|
|
96
|
+
<KanbanBoard<TaskPayload>
|
|
97
|
+
columns={COLUMNS}
|
|
98
|
+
items={ITEMS}
|
|
99
|
+
onMoveItem={handleMove}
|
|
100
|
+
showStageActions={true}
|
|
101
|
+
/>,
|
|
102
|
+
);
|
|
103
|
+
|
|
104
|
+
const forwardBtns = screen.getAllByRole('button', { name: 'Move forward' });
|
|
105
|
+
const firstForward = forwardBtns[0];
|
|
106
|
+
expect(firstForward).toBeDefined();
|
|
107
|
+
if (firstForward) {
|
|
108
|
+
fireEvent.click(firstForward);
|
|
109
|
+
expect(handleMove).toHaveBeenCalledWith('task-1', 'in_progress', 'todo');
|
|
110
|
+
}
|
|
111
|
+
});
|
|
112
|
+
|
|
113
|
+
it('moves item backward via stage button', () => {
|
|
114
|
+
const handleMove = vi.fn();
|
|
115
|
+
render(
|
|
116
|
+
<KanbanBoard<TaskPayload>
|
|
117
|
+
columns={COLUMNS}
|
|
118
|
+
items={ITEMS}
|
|
119
|
+
onMoveItem={handleMove}
|
|
120
|
+
showStageActions={true}
|
|
121
|
+
/>,
|
|
122
|
+
);
|
|
123
|
+
|
|
124
|
+
const backwardBtns = screen.getAllByRole('button', { name: 'Move backward' });
|
|
125
|
+
const inProgressBtn = backwardBtns.find((btn) => !btn.hasAttribute('disabled'));
|
|
126
|
+
expect(inProgressBtn).toBeTruthy();
|
|
127
|
+
if (inProgressBtn) {
|
|
128
|
+
fireEvent.click(inProgressBtn);
|
|
129
|
+
expect(handleMove).toHaveBeenCalledWith('task-2', 'todo', 'in_progress');
|
|
130
|
+
}
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
it('handles drag and drop between columns', () => {
|
|
134
|
+
const handleMove = vi.fn();
|
|
135
|
+
const { container } = render(
|
|
136
|
+
<KanbanBoard<TaskPayload>
|
|
137
|
+
columns={COLUMNS}
|
|
138
|
+
items={ITEMS}
|
|
139
|
+
onMoveItem={handleMove}
|
|
140
|
+
/>,
|
|
141
|
+
);
|
|
142
|
+
|
|
143
|
+
const card = screen.getByText('Prepare blueprints').closest('.udb-kanban-card');
|
|
144
|
+
const doneCol = container.querySelector('[data-column-id="done"]');
|
|
145
|
+
|
|
146
|
+
expect(card).toBeTruthy();
|
|
147
|
+
expect(doneCol).toBeTruthy();
|
|
148
|
+
|
|
149
|
+
if (card && doneCol) {
|
|
150
|
+
const dataTransfer = {
|
|
151
|
+
setData: vi.fn(),
|
|
152
|
+
getData: vi.fn(() => 'task-1'),
|
|
153
|
+
effectAllowed: 'move',
|
|
154
|
+
dropEffect: 'move',
|
|
155
|
+
};
|
|
156
|
+
|
|
157
|
+
fireEvent.dragStart(card, { dataTransfer });
|
|
158
|
+
fireEvent.dragOver(doneCol, { dataTransfer });
|
|
159
|
+
fireEvent.drop(doneCol, { dataTransfer });
|
|
160
|
+
|
|
161
|
+
expect(handleMove).toHaveBeenCalledWith('task-1', 'done', 'todo');
|
|
162
|
+
}
|
|
163
|
+
});
|
|
164
|
+
|
|
165
|
+
it('prevents dropping into column where canDrop is false', () => {
|
|
166
|
+
const handleMove = vi.fn();
|
|
167
|
+
const blockedCols: readonly KanbanColumn<TaskPayload>[] = [
|
|
168
|
+
{ id: 'todo', title: 'To Do', tone: 'neutral' },
|
|
169
|
+
{ id: 'in_progress', title: 'In Progress', tone: 'primary' },
|
|
170
|
+
{ id: 'done', title: 'Done', tone: 'success', canDrop: false },
|
|
171
|
+
];
|
|
172
|
+
|
|
173
|
+
const { container } = render(
|
|
174
|
+
<KanbanBoard<TaskPayload>
|
|
175
|
+
columns={blockedCols}
|
|
176
|
+
items={ITEMS}
|
|
177
|
+
onMoveItem={handleMove}
|
|
178
|
+
/>,
|
|
179
|
+
);
|
|
180
|
+
|
|
181
|
+
const card = screen.getByText('Prepare blueprints').closest('.udb-kanban-card');
|
|
182
|
+
const doneCol = container.querySelector('[data-column-id="done"]');
|
|
183
|
+
|
|
184
|
+
if (card && doneCol) {
|
|
185
|
+
const dataTransfer = {
|
|
186
|
+
setData: vi.fn(),
|
|
187
|
+
getData: vi.fn(() => 'task-1'),
|
|
188
|
+
effectAllowed: 'move',
|
|
189
|
+
dropEffect: 'move',
|
|
190
|
+
};
|
|
191
|
+
|
|
192
|
+
fireEvent.drop(doneCol, { dataTransfer });
|
|
193
|
+
expect(handleMove).not.toHaveBeenCalled();
|
|
194
|
+
}
|
|
195
|
+
});
|
|
196
|
+
|
|
197
|
+
it('renders custom card when renderCard is provided', () => {
|
|
198
|
+
render(
|
|
199
|
+
<KanbanBoard<TaskPayload>
|
|
200
|
+
columns={COLUMNS}
|
|
201
|
+
items={ITEMS}
|
|
202
|
+
renderCard={(item) => <div data-testid={`custom-${item.id}`}>Custom: {item.title}</div>}
|
|
203
|
+
/>,
|
|
204
|
+
);
|
|
205
|
+
|
|
206
|
+
expect(screen.getByTestId('custom-task-1').textContent).toContain('Custom: Prepare blueprints');
|
|
207
|
+
});
|
|
208
|
+
|
|
209
|
+
it('indicates when column limit is exceeded', () => {
|
|
210
|
+
const overflowItems: readonly KanbanItem<TaskPayload>[] = [
|
|
211
|
+
...ITEMS,
|
|
212
|
+
{ id: 'task-3', columnId: 'in_progress', title: 'Task 3' },
|
|
213
|
+
{ id: 'task-4', columnId: 'in_progress', title: 'Task 4' },
|
|
214
|
+
];
|
|
215
|
+
|
|
216
|
+
render(
|
|
217
|
+
<KanbanBoard<TaskPayload>
|
|
218
|
+
columns={COLUMNS}
|
|
219
|
+
items={overflowItems}
|
|
220
|
+
/>,
|
|
221
|
+
);
|
|
222
|
+
|
|
223
|
+
const limitPill = screen.getByText('/ 2');
|
|
224
|
+
expect(limitPill.className).toContain('is-exceeded');
|
|
225
|
+
});
|
|
226
|
+
});
|
|
@@ -0,0 +1,135 @@
|
|
|
1
|
+
import { useCallback, useMemo, useState, type DragEvent, type ReactNode } from 'react';
|
|
2
|
+
import type { KanbanBoardProps, KanbanCardActions, KanbanColumn as IKanbanColumn, KanbanItem } from '../types';
|
|
3
|
+
import { KanbanColumn } from './KanbanColumn';
|
|
4
|
+
|
|
5
|
+
export function KanbanBoard<T = unknown>({
|
|
6
|
+
columns,
|
|
7
|
+
items,
|
|
8
|
+
onMoveItem,
|
|
9
|
+
onSelectItem,
|
|
10
|
+
onColumnAction,
|
|
11
|
+
renderCard,
|
|
12
|
+
renderColumnHeader,
|
|
13
|
+
renderColumnFooter,
|
|
14
|
+
renderEmptyColumn,
|
|
15
|
+
showStageActions = true,
|
|
16
|
+
emptyText,
|
|
17
|
+
className,
|
|
18
|
+
columnClassName,
|
|
19
|
+
cardClassName,
|
|
20
|
+
}: KanbanBoardProps<T>): ReactNode {
|
|
21
|
+
const [draggingItemId, setDraggingItemId] = useState<string | null>(null);
|
|
22
|
+
|
|
23
|
+
const itemsByColumn = useMemo(() => {
|
|
24
|
+
const map = new Map<string, KanbanItem<T>[]>();
|
|
25
|
+
for (const col of columns) {
|
|
26
|
+
map.set(col.id, []);
|
|
27
|
+
}
|
|
28
|
+
for (const item of items) {
|
|
29
|
+
const list = map.get(item.columnId);
|
|
30
|
+
if (list) {
|
|
31
|
+
list.push(item);
|
|
32
|
+
} else {
|
|
33
|
+
map.set(item.columnId, [item]);
|
|
34
|
+
}
|
|
35
|
+
}
|
|
36
|
+
return map;
|
|
37
|
+
}, [columns, items]);
|
|
38
|
+
|
|
39
|
+
const columnIndexMap = useMemo(() => {
|
|
40
|
+
const map = new Map<string, number>();
|
|
41
|
+
columns.forEach((col, idx) => {
|
|
42
|
+
map.set(col.id, idx);
|
|
43
|
+
});
|
|
44
|
+
return map;
|
|
45
|
+
}, [columns]);
|
|
46
|
+
|
|
47
|
+
const handleDragStartCard = useCallback(
|
|
48
|
+
(_e: DragEvent<HTMLDivElement>, item: KanbanItem<T>) => {
|
|
49
|
+
setDraggingItemId(item.id);
|
|
50
|
+
},
|
|
51
|
+
[],
|
|
52
|
+
);
|
|
53
|
+
|
|
54
|
+
const handleDragEndCard = useCallback(() => {
|
|
55
|
+
setDraggingItemId(null);
|
|
56
|
+
}, []);
|
|
57
|
+
|
|
58
|
+
const handleDropItem = useCallback(
|
|
59
|
+
(targetColumnId: string, itemId: string) => {
|
|
60
|
+
setDraggingItemId(null);
|
|
61
|
+
const item = items.find((i) => i.id === itemId);
|
|
62
|
+
if (!item || item.columnId === targetColumnId) {
|
|
63
|
+
return;
|
|
64
|
+
}
|
|
65
|
+
const targetColumn = columns.find((c) => c.id === targetColumnId);
|
|
66
|
+
if (targetColumn) {
|
|
67
|
+
if (targetColumn.canDrop === false) {
|
|
68
|
+
return;
|
|
69
|
+
}
|
|
70
|
+
if (typeof targetColumn.canDrop === 'function' && !targetColumn.canDrop(item)) {
|
|
71
|
+
return;
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
onMoveItem?.(itemId, targetColumnId, item.columnId);
|
|
75
|
+
},
|
|
76
|
+
[columns, items, onMoveItem],
|
|
77
|
+
);
|
|
78
|
+
|
|
79
|
+
const getCardActions = useCallback(
|
|
80
|
+
(item: KanbanItem<T>, column: IKanbanColumn<T>): KanbanCardActions => {
|
|
81
|
+
const colIdx = columnIndexMap.get(column.id) ?? -1;
|
|
82
|
+
const canMoveBack = colIdx > 0;
|
|
83
|
+
const canMoveForward = colIdx >= 0 && colIdx < columns.length - 1;
|
|
84
|
+
|
|
85
|
+
return {
|
|
86
|
+
canMoveBack,
|
|
87
|
+
canMoveForward,
|
|
88
|
+
moveBack: () => {
|
|
89
|
+
if (canMoveBack) {
|
|
90
|
+
const prevCol = columns[colIdx - 1];
|
|
91
|
+
if (prevCol) {
|
|
92
|
+
onMoveItem?.(item.id, prevCol.id, column.id);
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
},
|
|
96
|
+
moveForward: () => {
|
|
97
|
+
if (canMoveForward) {
|
|
98
|
+
const nextCol = columns[colIdx + 1];
|
|
99
|
+
if (nextCol) {
|
|
100
|
+
onMoveItem?.(item.id, nextCol.id, column.id);
|
|
101
|
+
}
|
|
102
|
+
}
|
|
103
|
+
},
|
|
104
|
+
};
|
|
105
|
+
},
|
|
106
|
+
[columnIndexMap, columns, onMoveItem],
|
|
107
|
+
);
|
|
108
|
+
|
|
109
|
+
return (
|
|
110
|
+
<div className={`udb-kanban-board${className ? ` ${className}` : ''}`}>
|
|
111
|
+
{columns.map((column) => (
|
|
112
|
+
<KanbanColumn<T>
|
|
113
|
+
key={column.id}
|
|
114
|
+
column={column}
|
|
115
|
+
items={itemsByColumn.get(column.id) ?? []}
|
|
116
|
+
draggingItemId={draggingItemId}
|
|
117
|
+
getCardActions={getCardActions}
|
|
118
|
+
onDropItem={handleDropItem}
|
|
119
|
+
onSelectItem={onSelectItem}
|
|
120
|
+
onColumnAction={onColumnAction}
|
|
121
|
+
onDragStartCard={handleDragStartCard}
|
|
122
|
+
onDragEndCard={handleDragEndCard}
|
|
123
|
+
renderCard={renderCard}
|
|
124
|
+
renderColumnHeader={renderColumnHeader}
|
|
125
|
+
renderColumnFooter={renderColumnFooter}
|
|
126
|
+
renderEmptyColumn={renderEmptyColumn}
|
|
127
|
+
showStageActions={showStageActions}
|
|
128
|
+
emptyText={emptyText}
|
|
129
|
+
className={columnClassName}
|
|
130
|
+
cardClassName={cardClassName}
|
|
131
|
+
/>
|
|
132
|
+
))}
|
|
133
|
+
</div>
|
|
134
|
+
);
|
|
135
|
+
}
|