@transferwise/components 0.0.0-experimental-49c6983 → 0.0.0-experimental-7636184

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.
Files changed (87) hide show
  1. package/build/Provider/Provider.js +4 -1
  2. package/build/Provider/Provider.js.map +1 -1
  3. package/build/Provider/Provider.mjs +4 -1
  4. package/build/Provider/Provider.mjs.map +1 -1
  5. package/build/Snackbar/Snackbar.js +136 -105
  6. package/build/Snackbar/Snackbar.js.map +1 -1
  7. package/build/Snackbar/Snackbar.mjs +137 -103
  8. package/build/Snackbar/Snackbar.mjs.map +1 -1
  9. package/build/Snackbar/SnackbarContext.js.map +1 -1
  10. package/build/Snackbar/SnackbarContext.mjs.map +1 -1
  11. package/build/Snackbar/SnackbarPortal.js +12 -0
  12. package/build/Snackbar/SnackbarPortal.js.map +1 -0
  13. package/build/Snackbar/SnackbarPortal.mjs +8 -0
  14. package/build/Snackbar/SnackbarPortal.mjs.map +1 -0
  15. package/build/Snackbar/SnackbarProvider.js +24 -28
  16. package/build/Snackbar/SnackbarProvider.js.map +1 -1
  17. package/build/Snackbar/SnackbarProvider.mjs +25 -29
  18. package/build/Snackbar/SnackbarProvider.mjs.map +1 -1
  19. package/build/Snackbar/constants.js +14 -0
  20. package/build/Snackbar/constants.js.map +1 -0
  21. package/build/Snackbar/constants.mjs +9 -0
  22. package/build/Snackbar/constants.mjs.map +1 -0
  23. package/build/Snackbar/useSnackbarAutoDismiss.js +64 -0
  24. package/build/Snackbar/useSnackbarAutoDismiss.js.map +1 -0
  25. package/build/Snackbar/useSnackbarAutoDismiss.mjs +60 -0
  26. package/build/Snackbar/useSnackbarAutoDismiss.mjs.map +1 -0
  27. package/build/Snackbar/useSnackbarManager.js +144 -0
  28. package/build/Snackbar/useSnackbarManager.js.map +1 -0
  29. package/build/Snackbar/useSnackbarManager.mjs +140 -0
  30. package/build/Snackbar/useSnackbarManager.mjs.map +1 -0
  31. package/build/Typeahead/TypeaheadInput/TypeaheadInput.js +5 -5
  32. package/build/Typeahead/TypeaheadInput/TypeaheadInput.js.map +1 -1
  33. package/build/Typeahead/TypeaheadInput/TypeaheadInput.mjs +5 -5
  34. package/build/Typeahead/TypeaheadInput/TypeaheadInput.mjs.map +1 -1
  35. package/build/main.css +131 -61
  36. package/build/styles/Snackbar/Snackbar.css +105 -54
  37. package/build/styles/Typeahead/Typeahead.css +27 -8
  38. package/build/styles/main.css +131 -61
  39. package/build/types/Provider/Provider.d.ts.map +1 -1
  40. package/build/types/Snackbar/Snackbar.d.ts +48 -9
  41. package/build/types/Snackbar/Snackbar.d.ts.map +1 -1
  42. package/build/types/Snackbar/Snackbar.types.d.ts +12 -0
  43. package/build/types/Snackbar/Snackbar.types.d.ts.map +1 -0
  44. package/build/types/Snackbar/SnackbarContext.d.ts +2 -2
  45. package/build/types/Snackbar/SnackbarContext.d.ts.map +1 -1
  46. package/build/types/Snackbar/SnackbarPortal.d.ts +4 -0
  47. package/build/types/Snackbar/SnackbarPortal.d.ts.map +1 -0
  48. package/build/types/Snackbar/SnackbarProvider.d.ts +10 -0
  49. package/build/types/Snackbar/SnackbarProvider.d.ts.map +1 -1
  50. package/build/types/Snackbar/constants.d.ts +7 -0
  51. package/build/types/Snackbar/constants.d.ts.map +1 -0
  52. package/build/types/Snackbar/index.d.ts +1 -1
  53. package/build/types/Snackbar/index.d.ts.map +1 -1
  54. package/build/types/Snackbar/useSnackbar.d.ts +1 -1
  55. package/build/types/Snackbar/useSnackbar.d.ts.map +1 -1
  56. package/build/types/Snackbar/useSnackbarAutoDismiss.d.ts +12 -0
  57. package/build/types/Snackbar/useSnackbarAutoDismiss.d.ts.map +1 -0
  58. package/build/types/Snackbar/useSnackbarManager.d.ts +20 -0
  59. package/build/types/Snackbar/useSnackbarManager.d.ts.map +1 -0
  60. package/build/types/Typeahead/TypeaheadInput/TypeaheadInput.d.ts.map +1 -1
  61. package/build/types/index.d.ts +1 -1
  62. package/build/types/index.d.ts.map +1 -1
  63. package/package.json +1 -1
  64. package/src/ListItem/_stories/ListItem.scenarios.story.tsx +13 -16
  65. package/src/Provider/Provider.tsx +2 -1
  66. package/src/Snackbar/Snackbar.css +105 -54
  67. package/src/Snackbar/Snackbar.less +124 -60
  68. package/src/Snackbar/Snackbar.test.tsx +540 -120
  69. package/src/Snackbar/Snackbar.tsx +159 -99
  70. package/src/Snackbar/Snackbar.types.ts +17 -0
  71. package/src/Snackbar/SnackbarContext.ts +2 -2
  72. package/src/Snackbar/SnackbarPortal.tsx +8 -0
  73. package/src/Snackbar/SnackbarProvider.test.tsx +577 -0
  74. package/src/Snackbar/SnackbarProvider.tsx +32 -19
  75. package/src/Snackbar/_stories/Snackbar.rtl.test.story.tsx +13 -10
  76. package/src/Snackbar/_stories/Snackbar.story.tsx +132 -39
  77. package/src/Snackbar/_stories/Snackbar.test.story.tsx +101 -35
  78. package/src/Snackbar/constants.ts +7 -0
  79. package/src/Snackbar/index.ts +1 -1
  80. package/src/Snackbar/useSnackbarAutoDismiss.ts +72 -0
  81. package/src/Snackbar/useSnackbarManager.ts +159 -0
  82. package/src/Typeahead/Typeahead.css +27 -8
  83. package/src/Typeahead/Typeahead.less +32 -9
  84. package/src/Typeahead/TypeaheadInput/TypeaheadInput.tsx +5 -5
  85. package/src/Typeahead/_stories/Typeahead.test.story.tsx +0 -65
  86. package/src/index.ts +1 -1
  87. package/src/main.css +131 -61
@@ -1,25 +1,48 @@
1
- import { act, render, screen, userEvent } from '../test-utils';
2
- import Button from '../Button';
3
-
1
+ import { Card } from '@transferwise/icons';
2
+
3
+ import { act, mockMatchMedia, render, screen, userEvent } from '../test-utils';
4
+ import { WDS_LIVE_REGION_DELAY_MS } from '../common/constants';
5
+ import { resetLiveRegionAnnouncementQueue } from '../common/LiveRegion/LiveRegion';
6
+
7
+ import {
8
+ SNACKBAR_DEFAULT_DURATION,
9
+ SNACKBAR_ENTER_DURATION,
10
+ SNACKBAR_EXIT_DURATION,
11
+ SNACKBAR_EXTENDED_DURATION,
12
+ } from './constants';
4
13
  import { Snackbar, type SnackbarProps } from './Snackbar';
5
- import { SnackbarConsumer } from './SnackbarContext';
6
- import SnackbarProvider from './SnackbarProvider';
7
-
8
- const CSS_TRANSITION_DURATION = 400;
9
- const TIMEOUT = 4000;
10
14
 
11
15
  const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTimeAsync });
12
16
 
17
+ mockMatchMedia();
18
+
13
19
  const advanceTimers = (duration: number) => {
14
- act(() => {
15
- jest.advanceTimersByTime(duration);
16
- });
20
+ act(() => jest.advanceTimersByTime(duration));
17
21
  };
18
22
 
19
- const renderSnackbar = (props: Partial<SnackbarProps> = {}) =>
20
- render(<Snackbar text="" timeout={TIMEOUT} timestamp={0} {...props} />);
23
+ const enableLiveRegion = () => advanceTimers(WDS_LIVE_REGION_DELAY_MS);
24
+
25
+ const renderSnackbar = (props: Partial<SnackbarProps> = {}) => {
26
+ const snackbarProps: SnackbarProps = {
27
+ text: 'Changes saved',
28
+ timeout: SNACKBAR_DEFAULT_DURATION,
29
+ announcementKey: 1,
30
+ visible: true,
31
+ onDismissRequest: jest.fn(),
32
+ onExited: jest.fn(),
33
+ ...props,
34
+ };
35
+ return { ...render(<Snackbar {...snackbarProps} />), snackbarProps };
36
+ };
37
+
38
+ const renderEnteredSnackbar = (props: Partial<SnackbarProps> = {}) => {
39
+ const view = renderSnackbar(props);
40
+ advanceTimers(SNACKBAR_ENTER_DURATION);
41
+ return view;
42
+ };
21
43
 
22
44
  beforeEach(() => {
45
+ resetLiveRegionAnnouncementQueue();
23
46
  jest.useFakeTimers();
24
47
  });
25
48
 
@@ -28,179 +51,576 @@ afterEach(() => {
28
51
  jest.useRealTimers();
29
52
  });
30
53
 
31
- describe('Snackbar', () => {
32
- it('renders the live region wrapper even while no notification is shown', () => {
54
+ describe('Snackbar controlled surface', () => {
55
+ it('renders no live region while not visible', () => {
56
+ renderSnackbar({ visible: false });
57
+
58
+ expect(screen.queryByRole('status')).not.toBeInTheDocument();
59
+ });
60
+
61
+ it('renders the message when visible on mount', () => {
33
62
  renderSnackbar();
34
63
 
35
- expect(screen.getByRole('alert')).toHaveAttribute('aria-live', 'assertive');
36
- expect(screen.getByRole('alert')).toHaveClass('snackbar');
64
+ expect(screen.getByText('Changes saved')).toBeInTheDocument();
37
65
  });
38
66
 
39
- it('does not show a notification that is already present on mount', () => {
40
- renderSnackbar({ text: 'Changes saved', timestamp: 1 });
67
+ it('renders an action and calls its onClick handler', async () => {
68
+ const onClick = jest.fn();
69
+ const { snackbarProps } = renderSnackbar({ action: { label: 'View', onClick } });
41
70
 
42
- expect(screen.queryByText('Changes saved')).not.toBeInTheDocument();
71
+ await user.click(screen.getByRole('button', { name: 'View' }));
72
+
73
+ expect(onClick).toHaveBeenCalledTimes(1);
74
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
43
75
  });
44
76
 
45
- it('shows the notification once text arrives after mount', () => {
46
- const { rerender } = renderSnackbar();
77
+ it('runs the action before requesting dismissal', async () => {
78
+ const onDismissRequest = jest.fn();
79
+ const onClick = jest.fn(() => expect(onDismissRequest).not.toHaveBeenCalled());
80
+ renderSnackbar({ action: { label: 'Undo', onClick }, onDismissRequest });
47
81
 
48
- rerender(<Snackbar text="Changes saved" timeout={TIMEOUT} timestamp={1} />);
82
+ await user.click(screen.getByRole('button', { name: 'Undo' }));
49
83
 
50
- expect(screen.getByText('Changes saved')).toBeInTheDocument();
84
+ expect(onClick).toHaveBeenCalledTimes(1);
85
+ expect(onDismissRequest).toHaveBeenCalledTimes(1);
51
86
  });
52
87
 
53
- it('renders an action and calls its onClick handler', async () => {
54
- const onClick = jest.fn();
55
- const { rerender } = renderSnackbar();
56
-
57
- rerender(
58
- <Snackbar
59
- action={{ label: 'View', onClick }}
60
- text="Transfer completed"
61
- timeout={TIMEOUT}
62
- timestamp={1}
63
- />,
64
- );
65
- await user.click(screen.getByRole('button', { name: 'View' }));
88
+ it('requests dismissal even when the action throws, without swallowing its error', async () => {
89
+ const error = new Error('Action failed');
90
+ const handleError = jest.fn((event: ErrorEvent) => event.preventDefault());
91
+ const { snackbarProps } = renderSnackbar({
92
+ action: {
93
+ label: 'Undo',
94
+ onClick: () => {
95
+ throw error;
96
+ },
97
+ },
98
+ });
99
+ window.addEventListener('error', handleError);
100
+ try {
101
+ await user.click(screen.getByRole('button', { name: 'Undo' }));
102
+
103
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
104
+ expect(handleError).toHaveBeenCalled();
105
+ expect(handleError.mock.calls[0][0].error).toBe(error);
106
+ } finally {
107
+ window.removeEventListener('error', handleError);
108
+ }
109
+ });
110
+
111
+ it('requests dismissal for a navigation action without a callback', async () => {
112
+ const { snackbarProps } = renderSnackbar({
113
+ action: { label: 'View transfer', href: '/transfers/123', target: '_blank' },
114
+ });
115
+
116
+ await user.click(screen.getByRole('link', { name: 'View transfer' }));
117
+
118
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
119
+ });
120
+
121
+ it('renders a navigation action with a React-node label', () => {
122
+ renderSnackbar({
123
+ action: { label: <span>View transfer</span>, href: '/transfers/123', target: '_blank' },
124
+ });
125
+
126
+ const link = screen.getByRole('link', { name: 'View transfer' });
127
+ expect(link).toHaveAttribute('href', '/transfers/123');
128
+ expect(link).toHaveAttribute('target', '_blank');
129
+ expect(link).toHaveAttribute('rel', 'noopener noreferrer');
130
+ });
131
+
132
+ it('calls a navigation action handler when activated with the keyboard', async () => {
133
+ const onClick: React.MouseEventHandler<HTMLAnchorElement> = jest.fn((event) => {
134
+ event.preventDefault();
135
+ });
136
+ renderSnackbar({ action: { label: 'View transfer', href: '/transfers/123', onClick } });
137
+
138
+ act(() => screen.getByRole('link', { name: 'View transfer' }).focus());
139
+ await user.keyboard('{Enter}');
66
140
 
67
141
  expect(onClick).toHaveBeenCalledTimes(1);
68
142
  });
69
143
 
70
- it('dismisses the notification once the timeout elapses', () => {
71
- const { rerender } = renderSnackbar();
144
+ it('requests dismissal after the timeout without changing its own visibility', () => {
145
+ const onDismissRequest = jest.fn();
146
+ renderEnteredSnackbar({ onDismissRequest });
72
147
 
73
- rerender(<Snackbar text="Changes saved" timeout={TIMEOUT} timestamp={1} />);
148
+ advanceTimers(SNACKBAR_DEFAULT_DURATION - 1);
149
+ expect(onDismissRequest).not.toHaveBeenCalled();
74
150
 
75
- advanceTimers(TIMEOUT - 1);
151
+ advanceTimers(1);
152
+ expect(onDismissRequest).toHaveBeenCalledTimes(1);
76
153
  expect(screen.getByText('Changes saved')).toBeInTheDocument();
154
+ });
155
+
156
+ it('clears the dismissal timer when it begins exiting', () => {
157
+ const onDismissRequest = jest.fn();
158
+ const { rerender, snackbarProps } = renderEnteredSnackbar({ onDismissRequest });
159
+
160
+ rerender(<Snackbar {...snackbarProps} visible={false} />);
161
+ advanceTimers(SNACKBAR_DEFAULT_DURATION);
162
+
163
+ expect(onDismissRequest).not.toHaveBeenCalled();
164
+ });
165
+
166
+ it('notifies the provider only after its exit transition finishes', () => {
167
+ const onExited = jest.fn();
168
+ const { rerender, snackbarProps } = renderSnackbar({ onExited });
169
+
170
+ rerender(<Snackbar {...snackbarProps} visible={false} />);
171
+ advanceTimers(SNACKBAR_EXIT_DURATION - 1);
172
+ expect(onExited).not.toHaveBeenCalled();
77
173
 
78
174
  advanceTimers(1);
79
- advanceTimers(CSS_TRANSITION_DURATION);
175
+ expect(onExited).toHaveBeenCalledTimes(1);
80
176
  expect(screen.queryByText('Changes saved')).not.toBeInTheDocument();
81
177
  });
178
+ });
82
179
 
83
- it('exits the current notification before entering the next one', () => {
84
- const { rerender } = renderSnackbar();
180
+ describe('Snackbar duration', () => {
181
+ it.each([
182
+ ['default', 'extended', SNACKBAR_EXTENDED_DURATION],
183
+ ['extended', 'default', SNACKBAR_DEFAULT_DURATION],
184
+ ['indefinite', 'default', SNACKBAR_DEFAULT_DURATION],
185
+ ] as const)('starts a fresh duration when %s changes to %s', (initial, next, milliseconds) => {
186
+ const { rerender, snackbarProps } = renderEnteredSnackbar({ duration: initial });
187
+ advanceTimers(2000);
85
188
 
86
- rerender(<Snackbar text="First message" timeout={TIMEOUT} timestamp={1} />);
87
- rerender(<Snackbar text="Second message" timeout={TIMEOUT} timestamp={2} />);
189
+ rerender(<Snackbar {...snackbarProps} duration={next} />);
190
+
191
+ advanceTimers(milliseconds - 1);
192
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
193
+ advanceTimers(1);
194
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
195
+ });
88
196
 
89
- advanceTimers(CSS_TRANSITION_DURATION - 1);
90
- expect(screen.queryByText('Second message')).not.toBeInTheDocument();
197
+ it('cancels a running timer when the duration becomes indefinite', () => {
198
+ const { rerender, snackbarProps } = renderEnteredSnackbar({ duration: 'default' });
199
+ advanceTimers(2000);
91
200
 
201
+ rerender(<Snackbar {...snackbarProps} duration="indefinite" />);
202
+ advanceTimers(60_000);
203
+
204
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
205
+ expect(jest.getTimerCount()).toBe(0);
206
+ });
207
+
208
+ it('preserves remaining time when the dismissal callback changes while running', () => {
209
+ const { rerender, snackbarProps } = renderEnteredSnackbar({ duration: 'default' });
210
+ advanceTimers(SNACKBAR_DEFAULT_DURATION / 2);
211
+ const onDismissRequest = jest.fn();
212
+
213
+ rerender(<Snackbar {...snackbarProps} onDismissRequest={onDismissRequest} />);
214
+ advanceTimers(SNACKBAR_DEFAULT_DURATION / 2 - 1);
215
+ expect(onDismissRequest).not.toHaveBeenCalled();
92
216
  advanceTimers(1);
93
- expect(screen.getByText('Second message')).toBeInTheDocument();
94
- expect(screen.queryByText('First message')).not.toBeInTheDocument();
217
+ expect(onDismissRequest).toHaveBeenCalledTimes(1);
218
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
95
219
  });
96
220
 
97
- it('shows the next notification immediately when the previous one has already been dismissed', () => {
98
- const { rerender } = renderSnackbar();
221
+ it('preserves remaining time when the dismissal callback changes while paused', async () => {
222
+ const { rerender, snackbarProps } = renderEnteredSnackbar({ duration: 'default' });
223
+ const message = screen.getByText('Changes saved');
224
+ advanceTimers(SNACKBAR_DEFAULT_DURATION / 2);
225
+ await user.hover(message);
226
+ const onDismissRequest = jest.fn();
227
+
228
+ rerender(<Snackbar {...snackbarProps} onDismissRequest={onDismissRequest} />);
229
+ advanceTimers(SNACKBAR_DEFAULT_DURATION * 2);
230
+ expect(onDismissRequest).not.toHaveBeenCalled();
231
+ await user.unhover(message);
232
+ advanceTimers(SNACKBAR_DEFAULT_DURATION / 2 - 1);
233
+ expect(onDismissRequest).not.toHaveBeenCalled();
234
+ advanceTimers(1);
235
+ expect(onDismissRequest).toHaveBeenCalledTimes(1);
236
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
237
+ });
99
238
 
100
- rerender(<Snackbar text="First message" timeout={TIMEOUT} timestamp={1} />);
101
- advanceTimers(TIMEOUT + CSS_TRANSITION_DURATION);
239
+ it('starts the full reading duration only after the entry transition finishes', () => {
240
+ const { snackbarProps } = renderSnackbar({ duration: 'default' });
102
241
 
103
- rerender(<Snackbar text="Second message" timeout={TIMEOUT} timestamp={2} />);
104
- expect(screen.getByText('Second message')).toBeInTheDocument();
242
+ advanceTimers(SNACKBAR_ENTER_DURATION);
243
+ advanceTimers(SNACKBAR_DEFAULT_DURATION - 1);
244
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
245
+ advanceTimers(1);
246
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
105
247
  });
106
248
 
107
- it('restarts the timeout for a replacing notification', () => {
108
- const { rerender } = renderSnackbar();
249
+ it('does not start the timer when hover ends before entry finishes', async () => {
250
+ const { snackbarProps } = renderSnackbar({ duration: 'default' });
251
+ const message = screen.getByText('Changes saved');
252
+ await user.hover(message);
253
+ await user.unhover(message);
109
254
 
110
- rerender(<Snackbar text="First message" timeout={TIMEOUT} timestamp={1} />);
111
- advanceTimers(TIMEOUT - 100);
255
+ advanceTimers(SNACKBAR_ENTER_DURATION);
256
+ advanceTimers(SNACKBAR_DEFAULT_DURATION - 1);
257
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
258
+ advanceTimers(1);
259
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
260
+ });
112
261
 
113
- rerender(<Snackbar text="Second message" timeout={TIMEOUT} timestamp={2} />);
114
- advanceTimers(CSS_TRANSITION_DURATION);
115
- expect(screen.getByText('Second message')).toBeInTheDocument();
262
+ it('starts paused when keyboard focus enters during the entry transition', () => {
263
+ const { snackbarProps } = renderSnackbar({ duration: 'default', action: { label: 'Undo' } });
264
+ const action = screen.getByRole('button', { name: 'Undo' });
265
+ act(() => action.focus());
116
266
 
117
- advanceTimers(TIMEOUT - 1);
118
- expect(screen.getByText('Second message')).toBeInTheDocument();
267
+ advanceTimers(SNACKBAR_ENTER_DURATION);
268
+ advanceTimers(SNACKBAR_DEFAULT_DURATION * 2);
269
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
119
270
 
271
+ act(() => action.blur());
272
+ advanceTimers(SNACKBAR_DEFAULT_DURATION - 1);
273
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
120
274
  advanceTimers(1);
121
- advanceTimers(CSS_TRANSITION_DURATION);
122
- expect(screen.queryByText('Second message')).not.toBeInTheDocument();
275
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
123
276
  });
124
277
 
125
- it('dismisses a delayed replacement on the timeout current when it appears', () => {
126
- const { rerender } = renderSnackbar();
278
+ it('does not start the timer when focus leaves before entry finishes', () => {
279
+ const { snackbarProps } = renderSnackbar({ duration: 'default', action: { label: 'Undo' } });
280
+ const action = screen.getByRole('button', { name: 'Undo' });
281
+ act(() => action.focus());
282
+ act(() => action.blur());
127
283
 
128
- rerender(<Snackbar text="First message" timeout={TIMEOUT} timestamp={1} />);
129
- rerender(<Snackbar text="Second message" timeout={TIMEOUT} timestamp={2} />);
130
- // Shortened while the replacement is still waiting out the exit transition.
131
- rerender(<Snackbar text="Second message" timeout={1000} timestamp={2} />);
284
+ advanceTimers(SNACKBAR_ENTER_DURATION);
285
+ advanceTimers(SNACKBAR_DEFAULT_DURATION - 1);
286
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
287
+ advanceTimers(1);
288
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
289
+ });
132
290
 
133
- advanceTimers(CSS_TRANSITION_DURATION);
134
- expect(screen.getByText('Second message')).toBeInTheDocument();
291
+ it('uses four seconds when no duration or legacy timeout is supplied', () => {
292
+ const { snackbarProps } = renderEnteredSnackbar({ timeout: undefined });
135
293
 
136
- advanceTimers(1000);
137
- advanceTimers(CSS_TRANSITION_DURATION);
138
- expect(screen.queryByText('Second message')).not.toBeInTheDocument();
294
+ advanceTimers(SNACKBAR_DEFAULT_DURATION - 1);
295
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
296
+ advanceTimers(1);
297
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
298
+ });
299
+
300
+ it.each([
301
+ ['default', SNACKBAR_DEFAULT_DURATION],
302
+ ['extended', SNACKBAR_EXTENDED_DURATION],
303
+ ] as const)('uses the %s duration instead of the legacy timeout', (duration, milliseconds) => {
304
+ const { snackbarProps } = renderEnteredSnackbar({ duration, timeout: 1 });
305
+
306
+ advanceTimers(milliseconds - 1);
307
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
308
+ advanceTimers(1);
309
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
139
310
  });
140
311
 
141
- // Documents existing behaviour rather than endorsing it: clearing the text leaves the notification
142
- // on screen indefinitely, because the previous shouldComponentUpdate blocked the dismissal too.
143
- it('keeps the notification visible for as long as text is empty', () => {
144
- const { rerender } = renderSnackbar();
312
+ it.each([1000, 4500, 5000, 5001, 9000])(
313
+ 'preserves an explicit legacy timeout of %sms',
314
+ (timeout) => {
315
+ const { snackbarProps } = renderEnteredSnackbar({ timeout });
145
316
 
146
- rerender(<Snackbar text="Changes saved" timeout={TIMEOUT} timestamp={1} />);
147
- rerender(<Snackbar text="" timeout={TIMEOUT} timestamp={2} />);
317
+ advanceTimers(timeout - 1);
318
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
319
+ advanceTimers(1);
320
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
321
+ },
322
+ );
148
323
 
149
- advanceTimers(TIMEOUT + CSS_TRANSITION_DURATION);
150
- expect(screen.getByText('Changes saved')).toBeInTheDocument();
324
+ it('preserves a zero legacy timeout rather than using the default duration', () => {
325
+ const { snackbarProps } = renderEnteredSnackbar({ timeout: 0 });
326
+
327
+ advanceTimers(0);
328
+
329
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
330
+ });
331
+
332
+ it('does not auto-dismiss an indefinite Snackbar, even with a legacy timeout', () => {
333
+ const { snackbarProps } = renderEnteredSnackbar({ duration: 'indefinite', timeout: 1 });
334
+
335
+ advanceTimers(60_000);
336
+
337
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
338
+ expect(jest.getTimerCount()).toBe(0);
339
+ });
340
+
341
+ it('pauses on hover and resumes with only the remaining time', async () => {
342
+ const { snackbarProps } = renderEnteredSnackbar({ duration: 'default' });
343
+ const message = screen.getByText('Changes saved');
344
+
345
+ advanceTimers(2000);
346
+ await user.hover(message);
347
+ advanceTimers(10_000);
348
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
349
+
350
+ await user.unhover(message);
351
+ advanceTimers(1999);
352
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
353
+ advanceTimers(1);
354
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
151
355
  });
152
356
 
153
- it('ignores a repeated timestamp', () => {
154
- const { rerender } = renderSnackbar();
357
+ it('pauses on keyboard focus and resumes when focus leaves', () => {
358
+ const { snackbarProps } = renderEnteredSnackbar({
359
+ duration: 'default',
360
+ action: { label: 'Undo' },
361
+ });
155
362
 
156
- rerender(<Snackbar text="First message" timeout={TIMEOUT} timestamp={1} />);
157
- rerender(<Snackbar text="Second message" timeout={TIMEOUT} timestamp={1} />);
363
+ advanceTimers(2000);
364
+ act(() => screen.getByRole('button', { name: 'Undo' }).focus());
365
+ advanceTimers(10_000);
366
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
158
367
 
159
- advanceTimers(CSS_TRANSITION_DURATION);
160
- expect(screen.getByText('First message')).toBeInTheDocument();
161
- expect(screen.queryByText('Second message')).not.toBeInTheDocument();
368
+ act(() => screen.getByRole('button', { name: 'Undo' }).blur());
369
+ advanceTimers(1999);
370
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
371
+ advanceTimers(1);
372
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
373
+ });
374
+
375
+ it('stays paused when focus moves between Snackbar controls', () => {
376
+ const { snackbarProps } = renderEnteredSnackbar({
377
+ duration: 'default',
378
+ action: { label: 'Undo' },
379
+ });
380
+
381
+ advanceTimers(2000);
382
+ act(() => screen.getByRole('button', { name: 'Undo' }).focus());
383
+ act(() => screen.getByRole('button', { name: 'Close' }).focus());
384
+ advanceTimers(10_000);
385
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
386
+
387
+ act(() => screen.getByRole('button', { name: 'Close' }).blur());
388
+ advanceTimers(2000);
389
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
162
390
  });
163
391
 
164
- it('clears its pending dismissal timer on unmount', () => {
165
- const { rerender, unmount } = renderSnackbar();
392
+ it.each(['hover', 'focus'] as const)(
393
+ 'resumes only after both hover and focus end, with %s ending first',
394
+ async (firstToEnd) => {
395
+ const { snackbarProps } = renderEnteredSnackbar({
396
+ duration: 'default',
397
+ action: { label: 'Undo' },
398
+ });
399
+ const message = screen.getByText('Changes saved');
400
+ const action = screen.getByRole('button', { name: 'Undo' });
401
+
402
+ advanceTimers(2000);
403
+ await user.hover(message);
404
+ act(() => action.focus());
405
+ if (firstToEnd === 'hover') {
406
+ await user.unhover(message);
407
+ } else {
408
+ act(() => action.blur());
409
+ }
410
+ advanceTimers(10_000);
411
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
412
+
413
+ if (firstToEnd === 'hover') {
414
+ act(() => action.blur());
415
+ } else {
416
+ await user.unhover(message);
417
+ }
418
+ advanceTimers(1999);
419
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
420
+ advanceTimers(1);
421
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
422
+ },
423
+ );
424
+
425
+ it('keeps the remaining time across repeated pauses', async () => {
426
+ const { snackbarProps } = renderEnteredSnackbar({ duration: 'default' });
427
+ const message = screen.getByText('Changes saved');
428
+
429
+ advanceTimers(1000);
430
+ await user.hover(message);
431
+ advanceTimers(10_000);
432
+ await user.unhover(message);
433
+ advanceTimers(1000);
434
+ await user.hover(message);
435
+ advanceTimers(10_000);
436
+ await user.unhover(message);
437
+ advanceTimers(1999);
438
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
439
+ advanceTimers(1);
440
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
441
+ });
166
442
 
167
- rerender(<Snackbar text="Changes saved" timeout={TIMEOUT} timestamp={1} />);
168
- const pendingTimers = jest.getTimerCount();
443
+ it('cleans up a resumed timer when unmounted', async () => {
444
+ const { unmount, snackbarProps } = renderEnteredSnackbar({ duration: 'default' });
445
+ const message = screen.getByText('Changes saved');
446
+
447
+ advanceTimers(1000);
448
+ await user.hover(message);
449
+ await user.unhover(message);
169
450
  unmount();
451
+ advanceTimers(10_000);
170
452
 
171
- // The timer left behind belongs to CSSTransition's enter timeout, not to Snackbar.
172
- expect(jest.getTimerCount()).toBe(pendingTimers - 1);
453
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
454
+ expect(jest.getTimerCount()).toBe(0);
455
+ });
456
+
457
+ it('starts paused if the surface is already hovered when shown', async () => {
458
+ const matches = jest
459
+ .spyOn(HTMLElement.prototype, 'matches')
460
+ .mockImplementation((selector) => selector === ':hover');
461
+ let view: ReturnType<typeof renderSnackbar>;
462
+ try {
463
+ view = renderEnteredSnackbar({ duration: 'default' });
464
+ } finally {
465
+ matches.mockRestore();
466
+ }
467
+
468
+ advanceTimers(10_000);
469
+ expect(view.snackbarProps.onDismissRequest).not.toHaveBeenCalled();
470
+ const message = screen.getByText('Changes saved');
471
+ await user.hover(message);
472
+ await user.unhover(message);
473
+ advanceTimers(SNACKBAR_DEFAULT_DURATION - 1);
474
+ expect(view.snackbarProps.onDismissRequest).not.toHaveBeenCalled();
475
+ advanceTimers(1);
476
+ expect(view.snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
477
+ });
478
+
479
+ it('does not restart a paused timer while the Snackbar is exiting', async () => {
480
+ const { rerender, snackbarProps } = renderEnteredSnackbar({ duration: 'default' });
481
+ const message = screen.getByText('Changes saved');
482
+ advanceTimers(1000);
483
+ await user.hover(message);
484
+
485
+ rerender(<Snackbar {...snackbarProps} visible={false} />);
486
+ await user.unhover(message);
487
+ advanceTimers(10_000);
488
+
489
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
490
+ expect(jest.getTimerCount()).toBe(0);
173
491
  });
174
492
  });
175
493
 
176
- describe('Snackbar created through SnackbarProvider', () => {
177
- const renderProvider = () =>
178
- render(
179
- <SnackbarProvider timeout={TIMEOUT}>
180
- <SnackbarConsumer>
181
- {({ createSnackbar }) => (
182
- <Button onClick={() => createSnackbar({ text: 'Changes saved' })}>Show</Button>
183
- )}
184
- </SnackbarConsumer>
185
- </SnackbarProvider>,
494
+ describe('Snackbar loading', () => {
495
+ it.each(['neutral', 'success', 'warning', 'negative', 'proposition'] as const)(
496
+ 'replaces custom media and %s sentiment with the neutral loading indicator',
497
+ (sentiment) => {
498
+ renderSnackbar({ loading: true, sentiment, media: <Card title="Card" /> });
499
+
500
+ expect(screen.getByTestId('Snackbar_ProcessIndicator')).toHaveClass(
501
+ 'process-xs',
502
+ 'wds-Snackbar__process-indicator',
503
+ );
504
+ expect(screen.queryByTestId('card-icon')).not.toBeInTheDocument();
505
+ expect(screen.getByRole('status').closest('.wds-prompt')).toHaveClass(
506
+ 'wds-sentiment-neutral-light-elevated',
507
+ );
508
+ },
509
+ );
510
+
511
+ it.each([undefined, 'default', 'extended', 'indefinite'] as const)(
512
+ 'does not auto-dismiss while loading with duration %s, even with a zero timeout',
513
+ (duration) => {
514
+ const { snackbarProps } = renderEnteredSnackbar({ loading: true, duration, timeout: 0 });
515
+
516
+ advanceTimers(SNACKBAR_EXTENDED_DURATION * 2);
517
+
518
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
519
+ },
520
+ );
521
+
522
+ it('cancels a running timer when loading begins', () => {
523
+ const { rerender, snackbarProps } = renderEnteredSnackbar({ duration: 'default' });
524
+ advanceTimers(SNACKBAR_DEFAULT_DURATION / 2);
525
+
526
+ rerender(<Snackbar {...snackbarProps} loading />);
527
+ advanceTimers(SNACKBAR_EXTENDED_DURATION * 2);
528
+
529
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
530
+ });
531
+
532
+ it('starts a fresh duration after loading ends, respecting hover', async () => {
533
+ const { rerender, snackbarProps } = renderEnteredSnackbar({
534
+ loading: true,
535
+ duration: 'default',
536
+ sentiment: 'success',
537
+ media: <Card title="Card" />,
538
+ });
539
+ const message = screen.getByText('Changes saved');
540
+ await user.hover(message);
541
+
542
+ rerender(<Snackbar {...snackbarProps} loading={false} />);
543
+ advanceTimers(SNACKBAR_EXTENDED_DURATION * 2);
544
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
545
+ expect(screen.queryByTestId('Snackbar_ProcessIndicator')).not.toBeInTheDocument();
546
+ expect(screen.getByTestId('card-icon')).toBeInTheDocument();
547
+ expect(message.closest('.wds-prompt')).toHaveClass('wds-sentiment-success-light-elevated');
548
+
549
+ await user.unhover(message);
550
+ advanceTimers(SNACKBAR_DEFAULT_DURATION - 1);
551
+ expect(snackbarProps.onDismissRequest).not.toHaveBeenCalled();
552
+ advanceTimers(1);
553
+ expect(snackbarProps.onDismissRequest).toHaveBeenCalledTimes(1);
554
+ });
555
+ });
556
+
557
+ describe('Snackbar live region', () => {
558
+ it('announces the notification as a polite status message', () => {
559
+ renderSnackbar();
560
+ const liveRegion = screen.getByRole('status');
561
+
562
+ expect(liveRegion).toHaveAttribute('aria-live', 'polite');
563
+ expect(liveRegion).toHaveAttribute('aria-atomic', 'true');
564
+ expect(screen.queryByRole('alert')).not.toBeInTheDocument();
565
+ });
566
+
567
+ it('delays live-region exposure until assistive technology can observe the update', () => {
568
+ renderSnackbar();
569
+ const liveRegionContent = screen.getByRole('status').firstElementChild;
570
+
571
+ expect(liveRegionContent).toHaveAttribute('aria-hidden', 'true');
572
+ advanceTimers(WDS_LIVE_REGION_DELAY_MS - 1);
573
+ expect(liveRegionContent).toHaveAttribute('aria-hidden', 'true');
574
+
575
+ advanceTimers(1);
576
+ expect(liveRegionContent).not.toHaveAttribute('aria-hidden');
577
+ });
578
+
579
+ it('keeps interactive controls outside the delayed announcement subtree', () => {
580
+ renderSnackbar({ action: { label: 'Undo' } });
581
+
582
+ const liveRegionContent = screen.getByRole('status').firstElementChild;
583
+ const action = screen.getByRole('button', { name: 'Undo' });
584
+ const dismiss = screen.getByRole('button', { name: 'Close' });
585
+ expect(liveRegionContent).toHaveAttribute('aria-hidden', 'true');
586
+ expect(action.closest('[aria-hidden="true"]')).toBeNull();
587
+ expect(dismiss.closest('[aria-hidden="true"]')).toBeNull();
588
+ });
589
+ });
590
+
591
+ describe('Snackbar media', () => {
592
+ it('uses the shared PrimitivePrompt structure', () => {
593
+ renderSnackbar();
594
+ enableLiveRegion();
595
+
596
+ expect(screen.getByText('Changes saved').closest('.wds-prompt')).toHaveClass(
597
+ 'wds-Snackbar-container',
186
598
  );
599
+ expect(screen.getByRole('button', { name: 'Close' })).toHaveClass('wds-prompt__dismiss');
600
+ });
187
601
 
188
- it('shows a notification created through the context', async () => {
189
- renderProvider();
602
+ it('renders custom media in the fixed-size media wrapper', () => {
603
+ renderSnackbar({ media: <Card title="Card" /> });
190
604
 
191
- await user.click(screen.getByRole('button', { name: 'Show' }));
605
+ expect(screen.getByTestId('card-icon').parentElement).toHaveClass('wds-Snackbar__media-asset');
606
+ });
192
607
 
193
- expect(screen.getByText('Changes saved')).toBeInTheDocument();
608
+ it('renders proposition media in the fixed-size media wrapper', () => {
609
+ renderSnackbar({ sentiment: 'proposition' });
610
+ const icon = screen
611
+ .getByText('Changes saved')
612
+ .closest('.wds-prompt')
613
+ ?.querySelector('.tw-icon-tags');
614
+
615
+ expect(icon?.parentElement).toHaveClass('wds-Snackbar__media-asset');
194
616
  });
195
617
 
196
- it('shows only one notification when the trigger is clicked repeatedly', async () => {
197
- renderProvider();
618
+ it('requests dismissal through the close button', async () => {
619
+ const onDismissRequest = jest.fn();
620
+ renderSnackbar({ onDismissRequest });
198
621
 
199
- const trigger = screen.getByRole('button', { name: 'Show' });
200
- await user.click(trigger);
201
- await user.click(trigger);
202
- await user.click(trigger);
622
+ await user.click(screen.getByRole('button', { name: 'Close' }));
203
623
 
204
- expect(screen.getAllByRole('alert')).toHaveLength(1);
624
+ expect(onDismissRequest).toHaveBeenCalledTimes(1);
205
625
  });
206
626
  });