@qualtrics/ui-react 0.27.1

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.
@@ -0,0 +1,2635 @@
1
+ import React, { useContext, useState, useEffect, useLayoutEffect, useReducer, useCallback, useRef, useMemo } from 'react';
2
+ import PropTypes from 'prop-types';
3
+ import classNames from 'classnames';
4
+ import { styles, getStyleOverridesStore } from '@qualtrics/component-styles';
5
+ import { placements, Manager, Reference, Popper as Popper$1 } from 'react-popper';
6
+ import ReactDOM from 'react-dom';
7
+
8
+ var version = "0.27.1";
9
+
10
+ function _defineProperty(obj, key, value) {
11
+ if (key in obj) {
12
+ Object.defineProperty(obj, key, {
13
+ value: value,
14
+ enumerable: true,
15
+ configurable: true,
16
+ writable: true
17
+ });
18
+ } else {
19
+ obj[key] = value;
20
+ }
21
+
22
+ return obj;
23
+ }
24
+
25
+ function _extends() {
26
+ _extends = Object.assign || function (target) {
27
+ for (var i = 1; i < arguments.length; i++) {
28
+ var source = arguments[i];
29
+
30
+ for (var key in source) {
31
+ if (Object.prototype.hasOwnProperty.call(source, key)) {
32
+ target[key] = source[key];
33
+ }
34
+ }
35
+ }
36
+
37
+ return target;
38
+ };
39
+
40
+ return _extends.apply(this, arguments);
41
+ }
42
+
43
+ function ownKeys(object, enumerableOnly) {
44
+ var keys = Object.keys(object);
45
+
46
+ if (Object.getOwnPropertySymbols) {
47
+ var symbols = Object.getOwnPropertySymbols(object);
48
+ if (enumerableOnly) symbols = symbols.filter(function (sym) {
49
+ return Object.getOwnPropertyDescriptor(object, sym).enumerable;
50
+ });
51
+ keys.push.apply(keys, symbols);
52
+ }
53
+
54
+ return keys;
55
+ }
56
+
57
+ function _objectSpread2(target) {
58
+ for (var i = 1; i < arguments.length; i++) {
59
+ var source = arguments[i] != null ? arguments[i] : {};
60
+
61
+ if (i % 2) {
62
+ ownKeys(source, true).forEach(function (key) {
63
+ _defineProperty(target, key, source[key]);
64
+ });
65
+ } else if (Object.getOwnPropertyDescriptors) {
66
+ Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
67
+ } else {
68
+ ownKeys(source).forEach(function (key) {
69
+ Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
70
+ });
71
+ }
72
+ }
73
+
74
+ return target;
75
+ }
76
+
77
+ function _objectWithoutPropertiesLoose(source, excluded) {
78
+ if (source == null) return {};
79
+ var target = {};
80
+ var sourceKeys = Object.keys(source);
81
+ var key, i;
82
+
83
+ for (i = 0; i < sourceKeys.length; i++) {
84
+ key = sourceKeys[i];
85
+ if (excluded.indexOf(key) >= 0) continue;
86
+ target[key] = source[key];
87
+ }
88
+
89
+ return target;
90
+ }
91
+
92
+ function _objectWithoutProperties(source, excluded) {
93
+ if (source == null) return {};
94
+
95
+ var target = _objectWithoutPropertiesLoose(source, excluded);
96
+
97
+ var key, i;
98
+
99
+ if (Object.getOwnPropertySymbols) {
100
+ var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
101
+
102
+ for (i = 0; i < sourceSymbolKeys.length; i++) {
103
+ key = sourceSymbolKeys[i];
104
+ if (excluded.indexOf(key) >= 0) continue;
105
+ if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
106
+ target[key] = source[key];
107
+ }
108
+ }
109
+
110
+ return target;
111
+ }
112
+
113
+ function _slicedToArray(arr, i) {
114
+ return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
115
+ }
116
+
117
+ function _toConsumableArray(arr) {
118
+ return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
119
+ }
120
+
121
+ function _arrayWithoutHoles(arr) {
122
+ if (Array.isArray(arr)) {
123
+ for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
124
+
125
+ return arr2;
126
+ }
127
+ }
128
+
129
+ function _arrayWithHoles(arr) {
130
+ if (Array.isArray(arr)) return arr;
131
+ }
132
+
133
+ function _iterableToArray(iter) {
134
+ if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
135
+ }
136
+
137
+ function _iterableToArrayLimit(arr, i) {
138
+ var _arr = [];
139
+ var _n = true;
140
+ var _d = false;
141
+ var _e = undefined;
142
+
143
+ try {
144
+ for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
145
+ _arr.push(_s.value);
146
+
147
+ if (i && _arr.length === i) break;
148
+ }
149
+ } catch (err) {
150
+ _d = true;
151
+ _e = err;
152
+ } finally {
153
+ try {
154
+ if (!_n && _i["return"] != null) _i["return"]();
155
+ } finally {
156
+ if (_d) throw _e;
157
+ }
158
+ }
159
+
160
+ return _arr;
161
+ }
162
+
163
+ function _nonIterableSpread() {
164
+ throw new TypeError("Invalid attempt to spread non-iterable instance");
165
+ }
166
+
167
+ function _nonIterableRest() {
168
+ throw new TypeError("Invalid attempt to destructure non-iterable instance");
169
+ }
170
+
171
+ var UIContext = React.createContext(styles); // default to built-in styles
172
+
173
+ function useStyles(key) {
174
+ var styles = useContext(UIContext);
175
+
176
+ if (key) {
177
+ return styles[key];
178
+ }
179
+
180
+ return styles;
181
+ }
182
+
183
+ var ButtonGroupContext = React.createContext({});
184
+
185
+ function useButtonGroupContext() {
186
+ return useContext(ButtonGroupContext);
187
+ }
188
+
189
+ var ButtonGroupContextProvider = function ButtonGroupContextProvider(_ref) {
190
+ var value = _ref.value,
191
+ children = _ref.children;
192
+ return React.createElement(ButtonGroupContext.Provider, {
193
+ value: value
194
+ }, children);
195
+ };
196
+
197
+ ButtonGroupContextProvider.propTypes = {
198
+ value: PropTypes.object.isRequired,
199
+ children: PropTypes.any.isRequired
200
+ };
201
+
202
+ var buttonKinds = ['default', 'primary', 'secondary', 'tertiary', 'danger'];
203
+ var Button = React.forwardRef(function Button(props, ref) {
204
+ var _classNames;
205
+
206
+ var styles = useStyles('ButtonStyles');
207
+
208
+ var children = props.children,
209
+ kind = props.kind,
210
+ disabled = props.disabled,
211
+ small = props.small,
212
+ full = props.full,
213
+ className = props.className,
214
+ type = props.type,
215
+ onClick = props.onClick,
216
+ onKeyDown = props.onKeyDown,
217
+ other = _objectWithoutProperties(props, ["children", "kind", "disabled", "small", "full", "className", "type", "onClick", "onKeyDown"]);
218
+
219
+ var _useButtonGroupContex = useButtonGroupContext(),
220
+ isInsideButtonGroup = _useButtonGroupContex.isInsideButtonGroup,
221
+ groupFull = _useButtonGroupContex.full,
222
+ groupSmall = _useButtonGroupContex.small;
223
+
224
+ var classes = classNames(className, styles.btn, (_classNames = {}, _defineProperty(_classNames, styles[kind], kind), _defineProperty(_classNames, styles.disabled, disabled), _defineProperty(_classNames, styles.small, small || groupSmall), _defineProperty(_classNames, styles.full, full || groupFull), _defineProperty(_classNames, styles.group, isInsideButtonGroup), _classNames));
225
+ var clickHandler = disabled ? null : onClick;
226
+ var keyDownHandler = disabled ? null : onKeyDown;
227
+ return React.createElement("button", _extends({}, other, {
228
+ type: type,
229
+ className: classes,
230
+ ref: ref,
231
+ onClick: clickHandler,
232
+ onKeyDown: keyDownHandler
233
+ }), children);
234
+ });
235
+ Button.propTypes = {
236
+ children: PropTypes.node,
237
+ kind: PropTypes.oneOf(buttonKinds),
238
+ disabled: PropTypes.bool,
239
+ small: PropTypes.bool,
240
+ full: PropTypes.bool,
241
+ className: PropTypes.string,
242
+ type: PropTypes.oneOf(['button', 'submit', 'reset']),
243
+ onClick: PropTypes.func,
244
+ onKeyDown: PropTypes.func
245
+ };
246
+ Button.defaultProps = {
247
+ children: null,
248
+ kind: 'default',
249
+ disabled: false,
250
+ small: false,
251
+ full: false,
252
+ className: '',
253
+ type: 'button',
254
+ onClick: null,
255
+ onKeyDown: null
256
+ };
257
+
258
+ var IconTypes = styles.IconTypes;
259
+ var IconSizes = {
260
+ small: 16,
261
+ medium: 24,
262
+ large: 32
263
+ };
264
+ var Icon = React.forwardRef(function Icon(props, ref) {
265
+ var IconData = useStyles('IconData');
266
+ var className = props.className,
267
+ style = props.style,
268
+ type = props.type,
269
+ size = props.size,
270
+ onClick = props.onClick;
271
+ var svgContent = IconData[type];
272
+ var pixels = IconSizes[size];
273
+ return React.createElement("svg", {
274
+ ref: ref,
275
+ onClick: onClick,
276
+ className: className,
277
+ style: style,
278
+ width: pixels,
279
+ height: pixels,
280
+ focusable: "false",
281
+ viewBox: "0 0 24 24",
282
+ xmlns: "http://www.w3.org/2000/svg",
283
+ dangerouslySetInnerHTML: {
284
+ __html: svgContent
285
+ } // eslint-disable-line react/no-danger
286
+
287
+ });
288
+ });
289
+ Icon.propTypes = {
290
+ type: PropTypes.oneOf(Object.keys(IconTypes)).isRequired,
291
+ size: PropTypes.oneOf(['small', 'medium', 'large']),
292
+ className: PropTypes.string,
293
+ style: PropTypes.object,
294
+ onClick: PropTypes.func
295
+ };
296
+ Icon.defaultProps = {
297
+ size: 'medium',
298
+ className: '',
299
+ style: {},
300
+ onClick: undefined
301
+ };
302
+
303
+ /* eslint-disable jsx-a11y/label-has-for */
304
+ var Label = React.forwardRef(function (props, ref) {
305
+ var styles = useStyles('LabelStyles');
306
+ var children = props.children,
307
+ className = props.className,
308
+ htmlFor = props.htmlFor,
309
+ style = props.style;
310
+ var classes = classNames(styles.label, className);
311
+ return React.createElement("label", {
312
+ htmlFor: htmlFor,
313
+ ref: ref,
314
+ className: classes,
315
+ style: style
316
+ }, React.Children.map(children, function (child) {
317
+ if (!React.isValidElement(child)) {
318
+ return child;
319
+ }
320
+
321
+ return React.cloneElement(child, {
322
+ className: classNames(child.props.className, styles.input)
323
+ });
324
+ }));
325
+ });
326
+ Label.propTypes = {
327
+ children: PropTypes.any,
328
+ className: PropTypes.string,
329
+ htmlFor: PropTypes.string,
330
+ style: PropTypes.object
331
+ };
332
+ Label.defaultProps = {
333
+ children: null,
334
+ className: null,
335
+ htmlFor: null,
336
+ style: {}
337
+ };
338
+
339
+ var Checkbox = React.forwardRef(function Checkbox(props, ref) {
340
+ var styles = useStyles('CheckboxStyles');
341
+ var id = props.id,
342
+ className = props.className,
343
+ checked = props.checked,
344
+ defaultChecked = props.defaultChecked,
345
+ onChange = props.onChange,
346
+ children = props.children,
347
+ testId = props.testId;
348
+ return React.createElement(Label, {
349
+ className: classNames(className, styles.label),
350
+ htmlFor: id
351
+ }, React.createElement("span", {
352
+ className: styles.checkbox
353
+ }, React.createElement("input", {
354
+ id: id,
355
+ ref: ref,
356
+ className: styles.input,
357
+ type: "checkbox",
358
+ checked: checked,
359
+ defaultChecked: defaultChecked,
360
+ onChange: onChange,
361
+ "data-testid": testId
362
+ }), React.createElement(Icon, {
363
+ className: styles.check,
364
+ type: IconTypes.Check,
365
+ size: "small"
366
+ })), children);
367
+ });
368
+ Checkbox.propTypes = {
369
+ id: PropTypes.string,
370
+ className: PropTypes.string,
371
+ checked: PropTypes.bool,
372
+ defaultChecked: PropTypes.bool,
373
+ onChange: PropTypes.func,
374
+ children: PropTypes.string.isRequired,
375
+ testId: PropTypes.string
376
+ };
377
+ Checkbox.defaultProps = {
378
+ id: undefined,
379
+ className: undefined,
380
+ checked: undefined,
381
+ defaultChecked: undefined,
382
+ onChange: undefined,
383
+ testId: undefined
384
+ };
385
+
386
+ var Switch = React.forwardRef(function Switch(props, ref) {
387
+ var styles = useStyles('SwitchStyles');
388
+ var id = props.id,
389
+ className = props.className,
390
+ checked = props.checked,
391
+ onChange = props.onChange,
392
+ children = props.children,
393
+ disabled = props.disabled,
394
+ value = props.value;
395
+
396
+ function handleChange(event) {
397
+ if (!disabled && onChange) {
398
+ onChange(event);
399
+ }
400
+ }
401
+
402
+ var disabledClass = _defineProperty({}, styles.disabled, disabled);
403
+
404
+ return React.createElement("label", {
405
+ htmlFor: id,
406
+ className: classNames(className, styles["switch"], disabledClass)
407
+ }, React.createElement("input", {
408
+ id: id,
409
+ ref: ref,
410
+ className: styles.input,
411
+ type: "checkbox",
412
+ checked: checked,
413
+ onChange: handleChange,
414
+ disabled: disabled,
415
+ value: value
416
+ }), React.createElement("span", {
417
+ className: styles.slider
418
+ }), children ? React.createElement("span", {
419
+ className: styles.children
420
+ }, children) : null);
421
+ });
422
+ Switch.propTypes = {
423
+ id: PropTypes.string,
424
+ className: PropTypes.string,
425
+ checked: PropTypes.bool,
426
+ onChange: PropTypes.func,
427
+ children: PropTypes.string,
428
+ disabled: PropTypes.bool,
429
+ value: PropTypes.any
430
+ };
431
+ Switch.defaultProps = {
432
+ id: null,
433
+ className: '',
434
+ checked: false,
435
+ onChange: null,
436
+ children: '',
437
+ disabled: false,
438
+ value: ''
439
+ };
440
+
441
+ var CaptionTypes = ['error', 'helper'];
442
+
443
+ var Caption = function Caption(props) {
444
+ var styles = useStyles('CaptionStyles');
445
+ var children = props.children,
446
+ type = props.type,
447
+ className = props.className;
448
+ var classes = classNames(className, styles.caption, styles[type]);
449
+ return React.createElement("div", {
450
+ className: classes
451
+ }, children);
452
+ };
453
+
454
+ Caption.propTypes = {
455
+ children: PropTypes.any,
456
+ className: PropTypes.string,
457
+ type: PropTypes.oneOf(CaptionTypes)
458
+ };
459
+ Caption.defaultProps = {
460
+ children: null,
461
+ className: null,
462
+ type: 'helper'
463
+ };
464
+
465
+ var RadioGroupContext = React.createContext({});
466
+
467
+ function useRadioGroupContext() {
468
+ return useContext(RadioGroupContext);
469
+ }
470
+
471
+ var RadioGroupContextProvider = function RadioGroupContextProvider(_ref) {
472
+ var value = _ref.value,
473
+ children = _ref.children;
474
+ return React.createElement(RadioGroupContext.Provider, {
475
+ value: value
476
+ }, children);
477
+ };
478
+
479
+ RadioGroupContextProvider.propTypes = {
480
+ value: PropTypes.object.isRequired,
481
+ children: PropTypes.any.isRequired
482
+ };
483
+
484
+ var Radio = React.forwardRef(function Radio(props, ref) {
485
+ var styles = useStyles('RadioStyles');
486
+ var id = props.id,
487
+ className = props.className,
488
+ children = props.children,
489
+ testId = props.testId,
490
+ value = props.value;
491
+
492
+ var _useRadioGroupContext = useRadioGroupContext(),
493
+ name = _useRadioGroupContext.name,
494
+ onChange = _useRadioGroupContext.onChange,
495
+ groupDefaultValue = _useRadioGroupContext.groupDefaultValue,
496
+ groupValue = _useRadioGroupContext.groupValue,
497
+ groupClasses = _useRadioGroupContext.groupClasses;
498
+
499
+ return React.createElement(Label, {
500
+ className: classNames(className, groupClasses, styles.label),
501
+ htmlFor: id
502
+ }, React.createElement("span", {
503
+ className: styles.radio
504
+ }, React.createElement("input", {
505
+ id: id,
506
+ ref: ref,
507
+ className: styles.input,
508
+ type: "radio",
509
+ checked: groupValue !== undefined ? value === groupValue : undefined,
510
+ defaultChecked: groupDefaultValue !== undefined ? value === groupDefaultValue : undefined,
511
+ name: name,
512
+ value: value,
513
+ onChange: onChange,
514
+ "data-testid": testId
515
+ }), React.createElement("span", {
516
+ className: styles.check
517
+ })), children);
518
+ });
519
+ Radio.propTypes = {
520
+ children: PropTypes.node.isRequired,
521
+ className: PropTypes.string,
522
+ id: PropTypes.string,
523
+ testId: PropTypes.string,
524
+ value: PropTypes.string.isRequired
525
+ };
526
+ Radio.defaultProps = {
527
+ className: undefined,
528
+ id: undefined,
529
+ testId: undefined
530
+ };
531
+
532
+ /**
533
+ * Returns a type check error if all children of the prop are not of the given type.
534
+ * @param {type} type - A component type
535
+ * @param {string} typeName - The name of the component type
536
+ * @return {function} A type checker
537
+ */
538
+
539
+ function allChildrenOfTypeChecker(type, typeName) {
540
+ return function (props, propName, componentName) {
541
+ var prop = props[propName];
542
+ var error = null;
543
+ React.Children.forEach(prop, function (child) {
544
+ if (child.type !== type) {
545
+ var childName = typeof child.type === 'function' ? child.type.name : child.type;
546
+ error = new Error("`".concat(componentName, "` only accepts children of type `").concat(typeName, "`, ") + "but found `".concat(childName, "`."));
547
+ }
548
+ });
549
+ return error;
550
+ };
551
+ }
552
+ /**
553
+ * Chains type checkers by adding the isRequired property.
554
+ * @param {function} validate - A validation function to chain
555
+ * @return A chained type checker
556
+ */
557
+
558
+
559
+ function createChainableTypeChecker(validate) {
560
+ function checkType(isRequired, props, propName, componentName, location, propFullName) {
561
+ var resolvedComponentName = componentName || '<<anonymous>>';
562
+ var resolvedPropFullName = propFullName || propName;
563
+
564
+ if (props[propName] == null) {
565
+ if (isRequired) {
566
+ return new Error("The ".concat(location, " `").concat(resolvedPropFullName, "` ") + "is marked as required in `".concat(resolvedComponentName, "`, ") + "but its value is `".concat(props[propName], "`."));
567
+ }
568
+
569
+ return null;
570
+ }
571
+
572
+ return validate(props, propName, componentName, location, propFullName);
573
+ }
574
+
575
+ var chainedCheckType = checkType.bind(null, false);
576
+ chainedCheckType.isRequired = checkType.bind(null, true);
577
+ return chainedCheckType;
578
+ }
579
+
580
+ var RadioGroup = React.forwardRef(function RadioGroup(props, ref) {
581
+ var styles = useStyles('RadioGroupStyles');
582
+ var id = props.id,
583
+ className = props.className,
584
+ label = props.label,
585
+ name = props.name,
586
+ defaultValue = props.defaultValue,
587
+ value = props.value,
588
+ onChange = props.onChange,
589
+ children = props.children,
590
+ testId = props.testId;
591
+ var classes = classNames(className, styles.radioGroup);
592
+ return React.createElement(RadioGroupContextProvider, {
593
+ value: {
594
+ name: name,
595
+ onChange: onChange,
596
+ groupDefaultValue: defaultValue,
597
+ groupValue: value,
598
+ groupClasses: styles.option
599
+ }
600
+ }, React.createElement("fieldset", {
601
+ id: id,
602
+ ref: ref,
603
+ className: classes,
604
+ "data-testid": testId
605
+ }, React.createElement("legend", {
606
+ className: styles.legend
607
+ }, label), children));
608
+ });
609
+ var allOfTypeRadio = createChainableTypeChecker(allChildrenOfTypeChecker(Radio, 'Radio'));
610
+ RadioGroup.propTypes = {
611
+ id: PropTypes.string,
612
+ className: PropTypes.string,
613
+ defaultValue: PropTypes.string,
614
+ label: PropTypes.string,
615
+ name: PropTypes.string,
616
+ value: PropTypes.string,
617
+ onChange: PropTypes.func,
618
+ children: allOfTypeRadio.isRequired,
619
+ testId: PropTypes.string
620
+ };
621
+ RadioGroup.defaultProps = {
622
+ id: undefined,
623
+ className: undefined,
624
+ defaultValue: undefined,
625
+ label: undefined,
626
+ name: undefined,
627
+ value: undefined,
628
+ onChange: undefined,
629
+ testId: undefined
630
+ };
631
+
632
+ /* eslint-disable no-param-reassign */
633
+ var assignRef = function assignRef(ref, value) {
634
+ if (ref == null) return;
635
+
636
+ if (typeof ref === 'function') {
637
+ ref(value);
638
+ } else {
639
+ try {
640
+ ref.current = value;
641
+ } catch (error) {
642
+ throw new Error("Cannot assign value \"".concat(value, "\" to ref \"").concat(ref, "\""));
643
+ }
644
+ }
645
+ };
646
+
647
+ var FileDetails = function FileDetails(props) {
648
+ var styles = useStyles('FilePickerStyles');
649
+ var files = props.files;
650
+
651
+ if (files) {
652
+ return React.createElement("span", {
653
+ className: styles['file-details']
654
+ }, Array.prototype.map.call(files, function (file) {
655
+ return React.createElement("span", {
656
+ className: styles['file-name'],
657
+ key: file.name
658
+ }, file.name);
659
+ }));
660
+ }
661
+
662
+ return null;
663
+ };
664
+
665
+ FileDetails.defaultProps = {
666
+ files: null
667
+ };
668
+ FileDetails.propTypes = {
669
+ files: PropTypes.oneOfType([PropTypes.instanceOf(FileList), PropTypes.arrayOf(PropTypes.object)])
670
+ };
671
+ var FilePicker = React.forwardRef(function (props, _ref) {
672
+ var styles = useStyles('FilePickerStyles');
673
+ var accept = props.accept,
674
+ ariaLabel = props.ariaLabel,
675
+ buttonText = props.buttonText,
676
+ className = props.className,
677
+ disabled = props.disabled,
678
+ id = props.id,
679
+ multiple = props.multiple,
680
+ onChange = props.onChange;
681
+ var fileInputRef = React.useRef();
682
+
683
+ var _React$useState = React.useState(),
684
+ _React$useState2 = _slicedToArray(_React$useState, 2),
685
+ files = _React$useState2[0],
686
+ setFiles = _React$useState2[1]; // TODO: replace with localized string
687
+
688
+
689
+ var chooseFileMessage = buttonText || (multiple ? 'Choose files' : 'Choose file');
690
+
691
+ var changeHandler = function changeHandler(e) {
692
+ setFiles(e.target.files);
693
+
694
+ if (typeof onChange === 'function') {
695
+ onChange(e);
696
+ }
697
+ };
698
+
699
+ return React.createElement("span", {
700
+ className: className
701
+ }, React.createElement(Button, {
702
+ disabled: disabled,
703
+ kind: "secondary",
704
+ onClick: function onClick() {
705
+ fileInputRef.current.click();
706
+ }
707
+ }, chooseFileMessage), React.createElement("input", {
708
+ accept: accept,
709
+ "aria-label": ariaLabel,
710
+ className: styles['file-input'],
711
+ disabled: disabled,
712
+ id: id,
713
+ multiple: multiple,
714
+ onChange: disabled ? null : changeHandler,
715
+ ref: function ref(node) {
716
+ fileInputRef.current = node;
717
+ assignRef(_ref, node);
718
+ },
719
+ type: "file"
720
+ }), React.createElement(FileDetails, {
721
+ files: files
722
+ }));
723
+ });
724
+ FilePicker.defaultProps = {
725
+ accept: null,
726
+ ariaLabel: null,
727
+ buttonText: null,
728
+ className: null,
729
+ disabled: false,
730
+ id: null,
731
+ multiple: false,
732
+ onChange: null
733
+ };
734
+ FilePicker.propTypes = {
735
+ accept: PropTypes.string,
736
+ ariaLabel: PropTypes.string,
737
+ buttonText: PropTypes.string,
738
+ className: PropTypes.string,
739
+ disabled: PropTypes.bool,
740
+ id: PropTypes.string,
741
+ multiple: PropTypes.bool,
742
+ onChange: PropTypes.func
743
+ };
744
+
745
+ var targets = ['_self', '_blank'];
746
+ var Link = React.forwardRef(function Link(props, ref) {
747
+ var styles = useStyles('LinkStyles');
748
+ var children = props.children,
749
+ href = props.href,
750
+ target = props.target,
751
+ className = props.className;
752
+ var classes = classNames(className, styles.link);
753
+ var rel = target !== '_self' ? 'noopener noreferrer' : null;
754
+
755
+ if (typeof children !== 'string') {
756
+ return null;
757
+ }
758
+
759
+ return React.createElement("a", {
760
+ href: href,
761
+ target: target,
762
+ rel: rel,
763
+ className: classes,
764
+ ref: ref
765
+ }, children);
766
+ });
767
+ Link.propTypes = {
768
+ children: PropTypes.string.isRequired,
769
+ className: PropTypes.string,
770
+ href: PropTypes.string,
771
+ target: PropTypes.oneOf(targets)
772
+ };
773
+ Link.defaultProps = {
774
+ className: '',
775
+ href: '#',
776
+ target: '_self'
777
+ };
778
+
779
+ var InputTypes = ['text', 'password', 'number', 'email', 'tel', 'url'];
780
+ var Input = React.forwardRef(function Input(props, ref) {
781
+ var _classNames, _classNames2;
782
+
783
+ var styles = useStyles('InputStyles');
784
+
785
+ var append = props.append,
786
+ ariaLabel = props.ariaLabel,
787
+ autoComplete = props.autoComplete,
788
+ className = props.className,
789
+ disabled = props.disabled,
790
+ defaultValue = props.defaultValue,
791
+ full = props.full,
792
+ id = props.id,
793
+ invalid = props.invalid,
794
+ multiline = props.multiline,
795
+ onBlur = props.onBlur,
796
+ onChange = props.onChange,
797
+ placeholder = props.placeholder,
798
+ prepend = props.prepend,
799
+ rows = props.rows,
800
+ small = props.small,
801
+ style = props.style,
802
+ testId = props.testId,
803
+ type = props.type,
804
+ value = props.value,
805
+ other = _objectWithoutProperties(props, ["append", "ariaLabel", "autoComplete", "className", "disabled", "defaultValue", "full", "id", "invalid", "multiline", "onBlur", "onChange", "placeholder", "prepend", "rows", "small", "style", "testId", "type", "value"]);
806
+
807
+ var inputClasses = classNames(styles.input, (_classNames = {}, _defineProperty(_classNames, styles.full, full), _defineProperty(_classNames, styles.invalid, invalid), _defineProperty(_classNames, styles.small, small), _defineProperty(_classNames, styles.multiline, multiline), _classNames));
808
+
809
+ var _React$useState = React.useState(false),
810
+ _React$useState2 = _slicedToArray(_React$useState, 2),
811
+ focused = _React$useState2[0],
812
+ setFocused = _React$useState2[1];
813
+
814
+ var blurHandler = function blurHandler(e) {
815
+ setFocused(false);
816
+
817
+ if (typeof onBlur === 'function') {
818
+ onBlur(e);
819
+ }
820
+ };
821
+
822
+ var focusHandler = function focusHandler() {
823
+ setFocused(true);
824
+ };
825
+
826
+ var InputComponent = multiline ? React.createElement("textarea", _extends({
827
+ "aria-label": ariaLabel,
828
+ autoComplete: autoComplete,
829
+ className: inputClasses,
830
+ "data-testid": testId,
831
+ disabled: disabled,
832
+ defaultValue: defaultValue,
833
+ id: id,
834
+ onBlur: blurHandler,
835
+ onChange: disabled ? null : onChange,
836
+ onFocus: focusHandler,
837
+ placeholder: placeholder,
838
+ rows: rows,
839
+ style: style,
840
+ value: value
841
+ }, other)) : React.createElement("input", _extends({
842
+ "aria-label": ariaLabel,
843
+ autoComplete: autoComplete,
844
+ className: inputClasses,
845
+ "data-testid": testId,
846
+ defaultValue: defaultValue,
847
+ disabled: disabled,
848
+ id: id,
849
+ onBlur: blurHandler,
850
+ onChange: disabled ? null : onChange,
851
+ onFocus: focusHandler,
852
+ placeholder: placeholder,
853
+ style: style,
854
+ type: type,
855
+ value: value
856
+ }, other));
857
+ return React.createElement("div", {
858
+ className: classNames(className, styles.inputContainer, (_classNames2 = {}, _defineProperty(_classNames2, styles.appended, append), _defineProperty(_classNames2, styles.disabled, disabled), _defineProperty(_classNames2, styles.focused, focused), _defineProperty(_classNames2, styles.full, full), _defineProperty(_classNames2, styles.invalid, invalid), _defineProperty(_classNames2, styles.multiline, multiline), _defineProperty(_classNames2, styles.prepended, prepend), _defineProperty(_classNames2, styles.small, small), _classNames2)),
859
+ ref: ref
860
+ }, prepend, InputComponent, append);
861
+ });
862
+
863
+ var validateAppendPrepend = function validateAppendPrepend(props, propName, componentName) {
864
+ var value = props[propName];
865
+
866
+ if (value != null && typeof value !== 'string' && value.type !== Icon) {
867
+ return new Error("Invalid value for '".concat(propName, "' prop supplied to '").concat(componentName, "': ").concat(value, ". The '").concat(propName, "' prop must be string or Icon."));
868
+ }
869
+
870
+ return null;
871
+ };
872
+
873
+ Input.propTypes = {
874
+ append: validateAppendPrepend,
875
+ autoComplete: PropTypes.string,
876
+ ariaLabel: PropTypes.string,
877
+ className: PropTypes.string,
878
+ defaultValue: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
879
+ disabled: PropTypes.bool,
880
+ full: PropTypes.bool,
881
+ id: PropTypes.string,
882
+ invalid: PropTypes.bool,
883
+ multiline: PropTypes.bool,
884
+ onBlur: PropTypes.func,
885
+ onChange: PropTypes.func,
886
+ placeholder: PropTypes.string,
887
+ prepend: validateAppendPrepend,
888
+ rows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
889
+ small: PropTypes.bool,
890
+ style: PropTypes.object,
891
+ testId: PropTypes.string,
892
+ type: PropTypes.oneOf(InputTypes),
893
+ value: PropTypes.oneOfType([PropTypes.string, PropTypes.number])
894
+ };
895
+ Input.defaultProps = {
896
+ append: undefined,
897
+ autoComplete: undefined,
898
+ ariaLabel: undefined,
899
+ className: undefined,
900
+ defaultValue: undefined,
901
+ disabled: false,
902
+ full: false,
903
+ id: undefined,
904
+ invalid: false,
905
+ multiline: undefined,
906
+ onBlur: undefined,
907
+ onChange: undefined,
908
+ placeholder: undefined,
909
+ prepend: undefined,
910
+ rows: 2,
911
+ small: false,
912
+ style: {},
913
+ testId: undefined,
914
+ type: 'text',
915
+ value: undefined
916
+ };
917
+
918
+ var Table = React.forwardRef(function Table(props, ref) {
919
+ var styles = useStyles('TableStyles');
920
+ var children = props.children,
921
+ className = props.className,
922
+ id = props.id;
923
+ return React.createElement("table", {
924
+ ref: ref,
925
+ id: id,
926
+ className: classNames(className, styles.table)
927
+ }, children);
928
+ });
929
+ Table.propTypes = {
930
+ children: PropTypes.node,
931
+ className: PropTypes.string,
932
+ id: PropTypes.string
933
+ };
934
+ Table.defaultProps = {
935
+ children: null,
936
+ className: null,
937
+ id: null
938
+ };
939
+
940
+ var TableBody = React.forwardRef(function TableBody(props, ref) {
941
+ var styles = useStyles('TableStyles');
942
+ var children = props.children,
943
+ className = props.className,
944
+ id = props.id;
945
+ return React.createElement("tbody", {
946
+ ref: ref,
947
+ id: id,
948
+ className: classNames(className, styles.tableBody)
949
+ }, children);
950
+ });
951
+ TableBody.propTypes = {
952
+ children: PropTypes.node,
953
+ className: PropTypes.string,
954
+ id: PropTypes.string
955
+ };
956
+ TableBody.defaultProps = {
957
+ children: null,
958
+ className: null,
959
+ id: null
960
+ };
961
+
962
+ var TableCell = React.forwardRef(function TableCell(props, ref) {
963
+ var styles = useStyles('TableStyles');
964
+ var children = props.children,
965
+ className = props.className,
966
+ id = props.id;
967
+ return React.createElement("td", {
968
+ ref: ref,
969
+ id: id,
970
+ className: classNames(className, styles.tableCell)
971
+ }, children);
972
+ });
973
+ TableCell.propTypes = {
974
+ children: PropTypes.node,
975
+ className: PropTypes.string,
976
+ id: PropTypes.string
977
+ };
978
+ TableCell.defaultProps = {
979
+ children: null,
980
+ className: null,
981
+ id: null
982
+ };
983
+
984
+ var TableHead = React.forwardRef(function TableHead(props, ref) {
985
+ var styles = useStyles('TableStyles');
986
+ var children = props.children,
987
+ className = props.className,
988
+ id = props.id;
989
+ return React.createElement("thead", {
990
+ ref: ref,
991
+ id: id,
992
+ className: classNames(className, styles.tableHead)
993
+ }, children);
994
+ });
995
+ TableHead.propTypes = {
996
+ children: PropTypes.node,
997
+ className: PropTypes.string,
998
+ id: PropTypes.string
999
+ };
1000
+ TableHead.defaultProps = {
1001
+ children: null,
1002
+ className: null,
1003
+ id: null
1004
+ };
1005
+
1006
+ var TableHeaderCell = React.forwardRef(function TableHeaderCell(props, ref) {
1007
+ var styles = useStyles('TableStyles');
1008
+ var children = props.children,
1009
+ className = props.className,
1010
+ id = props.id;
1011
+ return React.createElement("th", {
1012
+ ref: ref,
1013
+ id: id,
1014
+ className: classNames(className, styles.tableHeaderCell)
1015
+ }, children);
1016
+ });
1017
+ TableHeaderCell.propTypes = {
1018
+ children: PropTypes.node,
1019
+ className: PropTypes.string,
1020
+ id: PropTypes.string
1021
+ };
1022
+ TableHeaderCell.defaultProps = {
1023
+ children: null,
1024
+ className: null,
1025
+ id: null
1026
+ };
1027
+
1028
+ var TableRow = React.forwardRef(function TableRow(props, ref) {
1029
+ var styles = useStyles('TableStyles');
1030
+ var children = props.children,
1031
+ className = props.className,
1032
+ id = props.id;
1033
+ return React.createElement("tr", {
1034
+ ref: ref,
1035
+ id: id,
1036
+ className: classNames(className, styles.tableRow)
1037
+ }, children);
1038
+ });
1039
+ TableRow.propTypes = {
1040
+ children: PropTypes.node,
1041
+ className: PropTypes.string,
1042
+ id: PropTypes.string
1043
+ };
1044
+ TableRow.defaultProps = {
1045
+ children: null,
1046
+ className: null,
1047
+ id: null
1048
+ };
1049
+
1050
+ var Tab = React.forwardRef(function Tab(props, ref) {
1051
+ var styles = useStyles('TabsStyles');
1052
+ var id = props.id,
1053
+ label = props.label,
1054
+ active = props.active,
1055
+ onSelect = props.onSelect;
1056
+ var classes = classNames(styles.tab, _defineProperty({}, styles.active, active));
1057
+
1058
+ var handleKeyDown = function handleKeyDown(event) {
1059
+ if (event.key === 'Enter' || event.which === 32) {
1060
+ onSelect();
1061
+ }
1062
+ };
1063
+
1064
+ return React.createElement("div", {
1065
+ id: id,
1066
+ role: "tab",
1067
+ "aria-selected": active,
1068
+ tabIndex: 0,
1069
+ onClick: onSelect,
1070
+ onKeyDown: handleKeyDown,
1071
+ className: classes,
1072
+ ref: ref
1073
+ }, label);
1074
+ });
1075
+ Tab.propTypes = {
1076
+ children: PropTypes.node,
1077
+ // eslint-disable-line react/no-unused-prop-types
1078
+ id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
1079
+ label: PropTypes.string,
1080
+ active: PropTypes.bool,
1081
+ onSelect: PropTypes.func
1082
+ };
1083
+ Tab.defaultProps = {
1084
+ children: null,
1085
+ id: null,
1086
+ label: '',
1087
+ active: false,
1088
+ onSelect: null
1089
+ };
1090
+
1091
+ var Tabs = React.forwardRef(function Tabs(props, ref) {
1092
+ var styles = useStyles('TabsStyles');
1093
+ var children = props.children,
1094
+ className = props.className,
1095
+ style = props.style;
1096
+ var classes = classNames(className, styles.tabs);
1097
+
1098
+ var _useState = useState(0),
1099
+ _useState2 = _slicedToArray(_useState, 2),
1100
+ activeTab = _useState2[0],
1101
+ setActiveTab = _useState2[1];
1102
+
1103
+ function handleTabSelect(key) {
1104
+ setActiveTab(key);
1105
+ }
1106
+
1107
+ return React.createElement("div", {
1108
+ className: classes,
1109
+ style: style,
1110
+ ref: ref
1111
+ }, React.createElement("div", {
1112
+ role: "tablist",
1113
+ className: styles.bar
1114
+ }, React.Children.map(children, function (child, index) {
1115
+ return React.cloneElement(child, {
1116
+ index: index,
1117
+ id: index,
1118
+ active: activeTab === index,
1119
+ children: child.props.children,
1120
+ onSelect: function onSelect() {
1121
+ return handleTabSelect(index);
1122
+ }
1123
+ });
1124
+ })), React.Children.map(children, function (child, index) {
1125
+ var isActive = index === activeTab;
1126
+ var panelClasses = classNames(styles.panel, _defineProperty({}, styles.inactive, !isActive));
1127
+ return React.createElement("div", {
1128
+ role: "tabpanel",
1129
+ "aria-labelledby": index,
1130
+ className: panelClasses
1131
+ }, isActive ? child.props.children : null);
1132
+ }));
1133
+ });
1134
+ var allOfTypeTab = createChainableTypeChecker(allChildrenOfTypeChecker(Tab, 'Tab'));
1135
+ Tabs.propTypes = {
1136
+ children: allOfTypeTab.isRequired,
1137
+ className: PropTypes.string,
1138
+ style: PropTypes.object
1139
+ };
1140
+ Tabs.defaultProps = {
1141
+ className: '',
1142
+ style: {}
1143
+ };
1144
+
1145
+ /* eslint-disable consistent-return */
1146
+
1147
+ function useDocumentEvent(event, handler) {
1148
+ var enabled = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
1149
+ useEffect(function () {
1150
+ if (enabled) {
1151
+ document.addEventListener(event, handler);
1152
+ return function () {
1153
+ return document.removeEventListener(event, handler);
1154
+ };
1155
+ }
1156
+ }, [event, handler, enabled]);
1157
+ }
1158
+
1159
+ var MenuAnchor = React.forwardRef(function MenuAnchor(_ref, ref) {
1160
+ var label = _ref.label,
1161
+ onClick = _ref.onClick,
1162
+ onKeyDown = _ref.onKeyDown,
1163
+ ariaExpanded = _ref.ariaExpanded,
1164
+ disabled = _ref.disabled,
1165
+ className = _ref.className,
1166
+ testId = _ref.testId,
1167
+ kind = _ref.kind;
1168
+ var styles = useStyles('MenuStyles');
1169
+ return React.createElement(Button, {
1170
+ ref: ref,
1171
+ type: "button",
1172
+ className: classNames(styles.menuBtn, className, _defineProperty({}, styles.unlabelledButton, !label)),
1173
+ "aria-haspopup": "menu",
1174
+ "aria-expanded": ariaExpanded || undefined // aria-expanded should either be true or 'undefined'
1175
+ ,
1176
+ onClick: onClick,
1177
+ onKeyDown: onKeyDown,
1178
+ disabled: disabled,
1179
+ "data-testid": testId,
1180
+ kind: kind
1181
+ }, label, React.createElement(Icon, {
1182
+ className: styles.rightIcon,
1183
+ type: IconTypes.AngleDown
1184
+ }));
1185
+ });
1186
+ MenuAnchor.propTypes = {
1187
+ label: PropTypes.string,
1188
+ onClick: PropTypes.func,
1189
+ onKeyDown: PropTypes.func,
1190
+ ariaExpanded: PropTypes.bool,
1191
+ disabled: PropTypes.bool,
1192
+ className: PropTypes.string,
1193
+ testId: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
1194
+ kind: PropTypes.string
1195
+ };
1196
+ MenuAnchor.defaultProps = {
1197
+ label: undefined,
1198
+ onClick: undefined,
1199
+ onKeyDown: undefined,
1200
+ ariaExpanded: undefined,
1201
+ disabled: undefined,
1202
+ className: undefined,
1203
+ testId: undefined,
1204
+ kind: undefined
1205
+ };
1206
+
1207
+ var SubmenuAnchor = React.forwardRef(function SubmenuAnchor(_ref, ref) {
1208
+ var label = _ref.label,
1209
+ isHighlighted = _ref.isHighlighted,
1210
+ onMouseEnter = _ref.onMouseEnter,
1211
+ disabled = _ref.disabled,
1212
+ className = _ref.className,
1213
+ style = _ref.style;
1214
+ var styles = useStyles('MenuStyles');
1215
+ var classes = classNames(styles.menuItem, className, _defineProperty({}, styles.highlighted, isHighlighted));
1216
+ return React.createElement("div", {
1217
+ role: "menuitem",
1218
+ tabIndex: "-1",
1219
+ ref: ref,
1220
+ onMouseEnter: onMouseEnter,
1221
+ disabled: disabled,
1222
+ className: classes,
1223
+ style: style
1224
+ }, label, React.createElement(Icon, {
1225
+ className: styles.rightIcon,
1226
+ type: IconTypes.AngleRight
1227
+ }));
1228
+ });
1229
+ SubmenuAnchor.propTypes = {
1230
+ label: PropTypes.string,
1231
+ isHighlighted: PropTypes.bool,
1232
+ onMouseEnter: PropTypes.func,
1233
+ disabled: PropTypes.bool,
1234
+ className: PropTypes.string,
1235
+ style: PropTypes.object
1236
+ };
1237
+ SubmenuAnchor.defaultProps = {
1238
+ label: undefined,
1239
+ isHighlighted: undefined,
1240
+ onMouseEnter: undefined,
1241
+ disabled: undefined,
1242
+ className: undefined,
1243
+ style: undefined
1244
+ };
1245
+
1246
+ function Portal(_ref) {
1247
+ var children = _ref.children,
1248
+ portalTarget = _ref.portalTarget;
1249
+
1250
+ var _useState = useState(function () {
1251
+ return document.createElement('div');
1252
+ }),
1253
+ _useState2 = _slicedToArray(_useState, 1),
1254
+ container = _useState2[0];
1255
+
1256
+ useLayoutEffect(function () {
1257
+ (portalTarget || document.body).appendChild(container);
1258
+ return function () {
1259
+ return (portalTarget || document.body).removeChild(container);
1260
+ };
1261
+ }, [container, portalTarget]);
1262
+ return ReactDOM.createPortal(children, container);
1263
+ }
1264
+
1265
+ var modifiers = {
1266
+ preventOverflow: {
1267
+ enabled: false
1268
+ },
1269
+ hide: {
1270
+ enabled: false
1271
+ }
1272
+ };
1273
+
1274
+ var Popper = function Popper(_ref) {
1275
+ var open = _ref.open,
1276
+ anchor = _ref.anchor,
1277
+ children = _ref.children,
1278
+ placementProp = _ref.placement,
1279
+ anchorRef = _ref.anchorRef,
1280
+ popperRef = _ref.popperRef,
1281
+ portalTarget = _ref.portalTarget;
1282
+ return React.createElement(Manager, null, React.createElement(Reference, {
1283
+ innerRef: function innerRef(node) {
1284
+ return assignRef(anchorRef, node);
1285
+ }
1286
+ }, function (_ref2) {
1287
+ var ref = _ref2.ref;
1288
+ return React.cloneElement(anchor, {
1289
+ ref: ref
1290
+ });
1291
+ }), open && React.createElement(Portal, {
1292
+ portalTarget: portalTarget
1293
+ }, React.createElement(Popper$1, {
1294
+ placement: placementProp,
1295
+ modifiers: modifiers,
1296
+ innerRef: function innerRef(node) {
1297
+ return assignRef(popperRef, node);
1298
+ }
1299
+ }, function (_ref3) {
1300
+ var _ref4 = _ref3.ref,
1301
+ style = _ref3.style,
1302
+ placement = _ref3.placement,
1303
+ arrowProps = _ref3.arrowProps;
1304
+ return typeof children === 'function' ? children({
1305
+ ref: function ref(node) {
1306
+ assignRef(children.ref, node);
1307
+ assignRef(_ref4, node);
1308
+ },
1309
+ style: style,
1310
+ placement: placement,
1311
+ arrowProps: arrowProps
1312
+ }) : React.cloneElement(children, {
1313
+ ref: function ref(node) {
1314
+ assignRef(children.ref, node);
1315
+ assignRef(_ref4, node);
1316
+ },
1317
+ style: style,
1318
+ 'data-placement': placement
1319
+ });
1320
+ })));
1321
+ };
1322
+
1323
+ Popper.propTypes = {
1324
+ open: PropTypes.bool,
1325
+ anchor: PropTypes.element.isRequired,
1326
+ children: PropTypes.oneOfType([PropTypes.element, PropTypes.func]).isRequired,
1327
+ placement: PropTypes.oneOf(placements),
1328
+ anchorRef: PropTypes.oneOfType([PropTypes.shape({
1329
+ current: PropTypes.any
1330
+ }), PropTypes.func]),
1331
+ popperRef: PropTypes.oneOfType([PropTypes.shape({
1332
+ current: PropTypes.any
1333
+ }), PropTypes.func]),
1334
+ portalTarget: PropTypes.instanceOf(Element)
1335
+ };
1336
+ Popper.defaultProps = {
1337
+ open: false,
1338
+ placement: 'bottom-start',
1339
+ anchorRef: undefined,
1340
+ popperRef: undefined,
1341
+ portalTarget: undefined
1342
+ };
1343
+
1344
+ var MenuContext = React.createContext({});
1345
+
1346
+ function useMenuContext() {
1347
+ return useContext(MenuContext);
1348
+ }
1349
+
1350
+ var MenuContextProvider = function MenuContextProvider(_ref) {
1351
+ var value = _ref.value,
1352
+ children = _ref.children;
1353
+ return React.createElement(MenuContext.Provider, {
1354
+ value: value
1355
+ }, children);
1356
+ };
1357
+
1358
+ MenuContextProvider.propTypes = {
1359
+ value: PropTypes.object.isRequired,
1360
+ children: PropTypes.any.isRequired
1361
+ };
1362
+
1363
+ function reducer(state, action) {
1364
+ switch (action.type) {
1365
+ case 'CLOSE_MENU':
1366
+ return _objectSpread2({}, state, {
1367
+ focusedIndex: -1,
1368
+ open: false,
1369
+ shouldFocusAnchor: action.shouldFocusAnchor || false
1370
+ });
1371
+
1372
+ case 'OPEN_MENU':
1373
+ return _objectSpread2({}, state, {
1374
+ open: true,
1375
+ focusedIndex: typeof action.focusedIndex === 'number' ? action.focusedIndex : -1,
1376
+ shouldFocusAnchor: false
1377
+ });
1378
+
1379
+ case 'SELECT_ITEM':
1380
+ return _objectSpread2({}, state, {
1381
+ selectedValue: action.value,
1382
+ selectedLabel: action.label,
1383
+ focusedIndex: -1,
1384
+ shouldFocusAnchor: true,
1385
+ open: false
1386
+ });
1387
+
1388
+ case 'SET_FOCUSED_INDEX':
1389
+ return _objectSpread2({}, state, {
1390
+ focusedIndex: action.index
1391
+ });
1392
+
1393
+ default:
1394
+ throw new Error("Unknown action of type: ".concat(action.type));
1395
+ }
1396
+ }
1397
+
1398
+ function useMenuState(defaults) {
1399
+ var defaultValues = typeof defaults === 'function' ? defaults() : defaults || {};
1400
+
1401
+ var initialValue = _objectSpread2({
1402
+ selectedValue: null,
1403
+ selectedLabel: null,
1404
+ focusedIndex: -1,
1405
+ shouldFocusAnchor: false,
1406
+ open: false
1407
+ }, defaultValues);
1408
+
1409
+ var _useReducer = useReducer(reducer, initialValue),
1410
+ _useReducer2 = _slicedToArray(_useReducer, 2),
1411
+ state = _useReducer2[0],
1412
+ dispatch = _useReducer2[1];
1413
+
1414
+ var closeMenu = useCallback(function () {
1415
+ var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
1416
+ shouldFocusAnchor = _ref.shouldFocusAnchor;
1417
+
1418
+ return dispatch({
1419
+ type: 'CLOSE_MENU',
1420
+ shouldFocusAnchor: shouldFocusAnchor
1421
+ });
1422
+ }, []);
1423
+ var openMenu = useCallback(function () {
1424
+ var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
1425
+ focusedIndex = _ref2.focusedIndex;
1426
+
1427
+ return dispatch({
1428
+ type: 'OPEN_MENU',
1429
+ focusedIndex: focusedIndex
1430
+ });
1431
+ }, []);
1432
+ var selectItem = useCallback(function (value, label) {
1433
+ return dispatch({
1434
+ type: 'SELECT_ITEM',
1435
+ value: value,
1436
+ label: label
1437
+ });
1438
+ }, []);
1439
+ var setFocusedIndex = useCallback(function (index) {
1440
+ return dispatch({
1441
+ type: 'SET_FOCUSED_INDEX',
1442
+ index: index
1443
+ });
1444
+ }, []);
1445
+ var functions = useRef({
1446
+ closeMenu: closeMenu,
1447
+ openMenu: openMenu,
1448
+ selectItem: selectItem,
1449
+ setFocusedIndex: setFocusedIndex
1450
+ });
1451
+ return [state, functions.current];
1452
+ }
1453
+
1454
+ var SelectMenu = React.forwardRef(function SelectMenu(_ref, ref) {
1455
+ var defaultLabel = _ref.label,
1456
+ children = _ref.children,
1457
+ onChange = _ref.onChange,
1458
+ defaultValue = _ref.defaultValue,
1459
+ placement = _ref.placement,
1460
+ className = _ref.className,
1461
+ style = _ref.style,
1462
+ disabled = _ref.disabled,
1463
+ maxHeight = _ref.maxHeight,
1464
+ testId = _ref.testId,
1465
+ portalTarget = _ref.portalTarget,
1466
+ menuItemIndex = _ref.menuItemIndex,
1467
+ kind = _ref.kind;
1468
+ var styles = useStyles('MenuStyles');
1469
+
1470
+ var _useMenuContext = useMenuContext(),
1471
+ parentOnSelect = _useMenuContext.onSelect,
1472
+ parentSelectedValue = _useMenuContext.selectedValue,
1473
+ parentFocusedIndex = _useMenuContext.focusedIndex,
1474
+ parentSetFocusedIndex = _useMenuContext.setFocusedIndex;
1475
+
1476
+ var isSubmenu = Boolean(parentOnSelect);
1477
+
1478
+ var _useMenuState = useMenuState(function () {
1479
+ return {
1480
+ selectedValue: defaultValue,
1481
+ selectedLabel: defaultValue && getChildByValue(children, defaultValue).props.children
1482
+ };
1483
+ }),
1484
+ _useMenuState2 = _slicedToArray(_useMenuState, 2),
1485
+ _useMenuState2$ = _useMenuState2[0],
1486
+ open = _useMenuState2$.open,
1487
+ focusedIndex = _useMenuState2$.focusedIndex,
1488
+ ownSelectedValue = _useMenuState2$.selectedValue,
1489
+ selectedLabel = _useMenuState2$.selectedLabel,
1490
+ shouldFocusAnchor = _useMenuState2$.shouldFocusAnchor,
1491
+ _useMenuState2$2 = _useMenuState2[1],
1492
+ closeMenu = _useMenuState2$2.closeMenu,
1493
+ openMenu = _useMenuState2$2.openMenu,
1494
+ selectItem = _useMenuState2$2.selectItem,
1495
+ setFocusedIndex = _useMenuState2$2.setFocusedIndex;
1496
+
1497
+ var selectedValue = parentSelectedValue || ownSelectedValue;
1498
+ useDocumentEvent('click', closeMenu, open);
1499
+
1500
+ var onSelect = parentOnSelect || function (value, label) {
1501
+ selectItem(value, label);
1502
+ onChange && onChange(value, label);
1503
+ };
1504
+
1505
+ var handleAnchorClick = function handleAnchorClick() {
1506
+ open ? closeMenu() : openMenu();
1507
+ };
1508
+
1509
+ var numChildren = React.Children.count(children);
1510
+
1511
+ var handleAnchorKeyDown = function handleAnchorKeyDown(e) {
1512
+ if (!disabled) {
1513
+ if (e.key === 'Enter' || e.key === ' ' || e.key === 'ArrowDown') {
1514
+ e.preventDefault(); // prevent scroll
1515
+
1516
+ openMenu({
1517
+ focusedIndex: 0
1518
+ });
1519
+ } else if (e.key === 'ArrowUp') {
1520
+ e.preventDefault(); // prevent scroll
1521
+
1522
+ openMenu({
1523
+ focusedIndex: numChildren - 1
1524
+ });
1525
+ }
1526
+ }
1527
+ };
1528
+
1529
+ var handleMenuKeyDown = function handleMenuKeyDown(e) {
1530
+ if (e.key === 'Escape') {
1531
+ closeMenu({
1532
+ shouldFocusAnchor: true
1533
+ });
1534
+ }
1535
+
1536
+ if (e.key === 'ArrowDown') {
1537
+ e.preventDefault(); // prevent scroll
1538
+
1539
+ var i = focusedIndex;
1540
+ setFocusedIndex((i + 1) % numChildren);
1541
+ }
1542
+
1543
+ if (e.key === 'ArrowUp') {
1544
+ e.preventDefault(); // prevent scroll
1545
+
1546
+ var _i = focusedIndex;
1547
+ setFocusedIndex((_i - 1 + numChildren) % numChildren);
1548
+ }
1549
+ };
1550
+
1551
+ var menuItems = React.Children.map(children, function (child, index) {
1552
+ return React.cloneElement(child, {
1553
+ menuItemIndex: index
1554
+ });
1555
+ });
1556
+ var menuAnchorRef = useRef(null);
1557
+ var menuAnchor = isSubmenu ? React.createElement(SubmenuAnchor, {
1558
+ label: defaultLabel,
1559
+ isHighlighted: menuItemIndex === parentFocusedIndex,
1560
+ onMouseEnter: function onMouseEnter() {
1561
+ return parentSetFocusedIndex(menuItemIndex);
1562
+ },
1563
+ disabled: disabled,
1564
+ className: className,
1565
+ style: style,
1566
+ ref: ref
1567
+ }) : React.createElement(MenuAnchor, {
1568
+ label: selectedLabel || defaultLabel,
1569
+ onClick: handleAnchorClick,
1570
+ onKeyDown: handleAnchorKeyDown,
1571
+ ariaExpanded: open,
1572
+ testId: testId,
1573
+ disabled: disabled,
1574
+ className: className,
1575
+ style: style,
1576
+ ref: ref,
1577
+ kind: kind
1578
+ });
1579
+ useEffect(function () {
1580
+ if (shouldFocusAnchor) {
1581
+ menuAnchorRef.current.focus();
1582
+ }
1583
+ }, [shouldFocusAnchor]);
1584
+ var contextValue = {
1585
+ onSelect: onSelect,
1586
+ selectedValue: selectedValue,
1587
+ focusedIndex: focusedIndex,
1588
+ setFocusedIndex: setFocusedIndex
1589
+ };
1590
+ return React.createElement(Popper, {
1591
+ open: isSubmenu ? !disabled && menuItemIndex === parentFocusedIndex : open,
1592
+ anchor: menuAnchor,
1593
+ anchorRef: menuAnchorRef,
1594
+ portalTarget: portalTarget,
1595
+ placement: isSubmenu ? 'right-start' : placement
1596
+ }, React.createElement("div", {
1597
+ role: "menu",
1598
+ tabIndex: "-1",
1599
+ className: styles.menuItemsContainer,
1600
+ onKeyDown: handleMenuKeyDown,
1601
+ onClick: function onClick(e) {
1602
+ return e.nativeEvent.stopImmediatePropagation();
1603
+ }
1604
+ }, React.createElement("div", {
1605
+ style: {
1606
+ maxHeight: maxHeight
1607
+ },
1608
+ className: classNames(styles.menuItems, _defineProperty({}, styles.scrollable, !!maxHeight))
1609
+ }, React.createElement(MenuContextProvider, {
1610
+ value: contextValue
1611
+ }, menuItems))));
1612
+ });
1613
+
1614
+ function getChildByValue(children, value) {
1615
+ var result = null;
1616
+ var kids = React.Children.toArray(children);
1617
+
1618
+ for (var i = 0; i < kids.length; i += 1) {
1619
+ var child = kids[i];
1620
+
1621
+ if (child.props.value === value) {
1622
+ result = child;
1623
+ break;
1624
+ }
1625
+ }
1626
+
1627
+ return result;
1628
+ }
1629
+
1630
+ SelectMenu.propTypes = {
1631
+ label: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired,
1632
+ defaultValue: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
1633
+ children: PropTypes.node,
1634
+ onChange: PropTypes.func,
1635
+ placement: PropTypes.oneOf(placements),
1636
+ className: PropTypes.string,
1637
+ style: PropTypes.object,
1638
+ disabled: PropTypes.bool,
1639
+ maxHeight: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
1640
+ testId: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
1641
+ menuItemIndex: PropTypes.number,
1642
+ portalTarget: PropTypes.instanceOf(Element),
1643
+ kind: PropTypes.string
1644
+ };
1645
+ SelectMenu.defaultProps = {
1646
+ defaultValue: undefined,
1647
+ children: undefined,
1648
+ onChange: undefined,
1649
+ placement: 'bottom-start',
1650
+ className: undefined,
1651
+ style: undefined,
1652
+ disabled: undefined,
1653
+ maxHeight: undefined,
1654
+ testId: undefined,
1655
+ menuItemIndex: undefined,
1656
+ portalTarget: undefined,
1657
+ kind: undefined
1658
+ };
1659
+
1660
+ function useFocuser(ref, isFocused) {
1661
+ useEffect(function () {
1662
+ if (isFocused) {
1663
+ var x = window.scrollX;
1664
+ var y = window.scrollY;
1665
+ ref.current.focus();
1666
+ window.scrollTo(x, y);
1667
+ } else {
1668
+ ref.current.blur();
1669
+ }
1670
+ }, [isFocused, ref]);
1671
+ }
1672
+
1673
+ var MenuItem = React.forwardRef(function MenuItem(_ref, _ref2) {
1674
+ var value = _ref.value,
1675
+ label = _ref.children,
1676
+ onSelect = _ref.onSelect,
1677
+ className = _ref.className,
1678
+ style = _ref.style,
1679
+ disabled = _ref.disabled,
1680
+ testId = _ref.testId,
1681
+ menuItemIndex = _ref.menuItemIndex;
1682
+ var styles = useStyles('MenuStyles');
1683
+
1684
+ var _useMenuContext = useMenuContext(),
1685
+ selectedValue = _useMenuContext.selectedValue,
1686
+ focusedIndex = _useMenuContext.focusedIndex,
1687
+ setFocusedIndex = _useMenuContext.setFocusedIndex,
1688
+ onSelectMenu = _useMenuContext.onSelect;
1689
+
1690
+ var isSelected = selectedValue && value === selectedValue;
1691
+ var isFocused = menuItemIndex === focusedIndex;
1692
+ var menuItemRef = useRef(null);
1693
+ useFocuser(menuItemRef, isFocused);
1694
+ var classes = classNames(styles.menuItem, className, _defineProperty({}, styles.highlighted, isFocused));
1695
+
1696
+ var handleSelect = function handleSelect() {
1697
+ if (!disabled) {
1698
+ onSelectMenu(value, label);
1699
+ onSelect && onSelect();
1700
+ }
1701
+ };
1702
+
1703
+ var handleKeyDown = function handleKeyDown(event) {
1704
+ if (event.key === ' ' || event.key === 'Enter') {
1705
+ event.preventDefault(); // prevent scroll
1706
+
1707
+ handleSelect();
1708
+ }
1709
+ };
1710
+
1711
+ return React.createElement("div", {
1712
+ role: "menuitem",
1713
+ tabIndex: "-1" // focusable, not tabbable
1714
+ ,
1715
+ ref: function ref(node) {
1716
+ assignRef(_ref2, node);
1717
+ menuItemRef.current = node;
1718
+ },
1719
+ className: classes,
1720
+ style: style,
1721
+ disabled: disabled,
1722
+ onClick: handleSelect,
1723
+ onKeyDown: handleKeyDown,
1724
+ onMouseEnter: function onMouseEnter() {
1725
+ return setFocusedIndex(menuItemIndex);
1726
+ },
1727
+ onMouseLeave: function onMouseLeave() {
1728
+ return setFocusedIndex(-1);
1729
+ },
1730
+ onFocus: function onFocus(e) {
1731
+ return e.preventDefault();
1732
+ },
1733
+ onBlur: function onBlur(e) {
1734
+ return e.preventDefault();
1735
+ },
1736
+ "data-testid": testId
1737
+ }, isSelected && React.createElement(Icon, {
1738
+ className: styles.leftIcon,
1739
+ type: IconTypes.Check
1740
+ }), label);
1741
+ });
1742
+ MenuItem.propTypes = {
1743
+ value: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
1744
+ children: PropTypes.oneOfType([PropTypes.string, PropTypes.number, PropTypes.node]),
1745
+ onSelect: PropTypes.func,
1746
+ className: PropTypes.string,
1747
+ style: PropTypes.object,
1748
+ disabled: PropTypes.bool,
1749
+ testId: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
1750
+ menuItemIndex: PropTypes.number
1751
+ };
1752
+ MenuItem.defaultProps = {
1753
+ value: undefined,
1754
+ children: undefined,
1755
+ onSelect: undefined,
1756
+ className: undefined,
1757
+ style: undefined,
1758
+ disabled: undefined,
1759
+ testId: undefined,
1760
+ menuItemIndex: undefined
1761
+ };
1762
+
1763
+ var defaultEvents = ['mouseup', 'touchend'];
1764
+
1765
+ function useClickOutside(refs, onClickOutside) {
1766
+ var events = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultEvents;
1767
+ var allRefs = useMemo(function () {
1768
+ return Array.isArray(refs) ? refs : [refs];
1769
+ }, [refs]);
1770
+ var handleOutsideClick = useRef(onClickOutside);
1771
+ useEffect(function () {
1772
+ handleOutsideClick.current = onClickOutside;
1773
+ }, [onClickOutside]);
1774
+ useEffect(function () {
1775
+ var handler = function handler(event) {
1776
+ var isInside = allRefs.some(function (ref) {
1777
+ var el = ref.current;
1778
+ return el && el.contains(event.target);
1779
+ });
1780
+
1781
+ if (!isInside) {
1782
+ handleOutsideClick.current(event);
1783
+ }
1784
+ };
1785
+
1786
+ events.forEach(function (eventName) {
1787
+ return document.addEventListener(eventName, handler);
1788
+ });
1789
+ return function () {
1790
+ events.forEach(function (eventName) {
1791
+ return document.removeEventListener(eventName, handler);
1792
+ });
1793
+ };
1794
+ }, [allRefs, events]);
1795
+ }
1796
+
1797
+ var Menu = React.forwardRef(function Menu(_ref, ref) {
1798
+ var label = _ref.label,
1799
+ children = _ref.children,
1800
+ placement = _ref.placement,
1801
+ disabled = _ref.disabled,
1802
+ menuItemIndex = _ref.menuItemIndex,
1803
+ portalTarget = _ref.portalTarget,
1804
+ maxHeight = _ref.maxHeight,
1805
+ rest = _objectWithoutProperties(_ref, ["label", "children", "placement", "disabled", "menuItemIndex", "portalTarget", "maxHeight"]);
1806
+
1807
+ var styles = useStyles('MenuStyles');
1808
+
1809
+ var _useMenuContext = useMenuContext(),
1810
+ parentSetClickOutsideEnabled = _useMenuContext.setClickOutsideEnabled,
1811
+ parentRefs = _useMenuContext.refs,
1812
+ parentOnSelect = _useMenuContext.onSelect,
1813
+ parentFocusedIndex = _useMenuContext.focusedIndex,
1814
+ parentSetFocusedIndex = _useMenuContext.setFocusedIndex;
1815
+
1816
+ var isSubmenu = typeof parentFocusedIndex !== 'undefined';
1817
+ var menuItems = React.Children.map(children, function (child, index) {
1818
+ return React.cloneElement(child, {
1819
+ menuItemIndex: index
1820
+ });
1821
+ });
1822
+
1823
+ var _useMenuState = useMenuState(),
1824
+ _useMenuState2 = _slicedToArray(_useMenuState, 2),
1825
+ _useMenuState2$ = _useMenuState2[0],
1826
+ open = _useMenuState2$.open,
1827
+ focusedIndex = _useMenuState2$.focusedIndex,
1828
+ shouldFocusAnchor = _useMenuState2$.shouldFocusAnchor,
1829
+ _useMenuState2$2 = _useMenuState2[1],
1830
+ closeMenu = _useMenuState2$2.closeMenu,
1831
+ openMenu = _useMenuState2$2.openMenu,
1832
+ setFocusedIndex = _useMenuState2$2.setFocusedIndex;
1833
+
1834
+ var numChildren = React.Children.count(children);
1835
+
1836
+ var handleAnchorKeyDown = function handleAnchorKeyDown(e) {
1837
+ if (!disabled) {
1838
+ if (e.key === 'Enter' || e.key === ' ' || e.key === 'ArrowDown') {
1839
+ e.preventDefault(); // prevent scroll
1840
+
1841
+ openMenu({
1842
+ focusedIndex: 0
1843
+ });
1844
+ } else if (e.key === 'ArrowUp') {
1845
+ e.preventDefault(); // prevent scroll
1846
+
1847
+ openMenu({
1848
+ focusedIndex: numChildren - 1
1849
+ });
1850
+ }
1851
+ }
1852
+ };
1853
+
1854
+ var handleMenuKeyDown = function handleMenuKeyDown(e) {
1855
+ if (e.key === 'Escape') {
1856
+ closeMenu({
1857
+ shouldFocusAnchor: true
1858
+ });
1859
+ }
1860
+
1861
+ if (e.key === 'ArrowDown') {
1862
+ e.preventDefault(); // prevent scroll
1863
+
1864
+ var i = focusedIndex;
1865
+ setFocusedIndex((i + 1) % numChildren);
1866
+ }
1867
+
1868
+ if (e.key === 'ArrowUp') {
1869
+ e.preventDefault(); // prevent scroll
1870
+
1871
+ var _i = focusedIndex;
1872
+ setFocusedIndex((_i - 1 + numChildren) % numChildren);
1873
+ }
1874
+ };
1875
+
1876
+ var handleAnchorClick = function handleAnchorClick() {
1877
+ open ? closeMenu() : openMenu();
1878
+ };
1879
+
1880
+ var menuAnchorRef = useRef(null);
1881
+ var menuAnchor = isSubmenu ? React.createElement(SubmenuAnchor, _extends({}, rest, {
1882
+ ref: ref,
1883
+ label: label,
1884
+ isHighlighted: menuItemIndex === parentFocusedIndex,
1885
+ onMouseEnter: function onMouseEnter() {
1886
+ return parentSetFocusedIndex(menuItemIndex);
1887
+ },
1888
+ disabled: disabled
1889
+ })) : React.createElement(MenuAnchor, _extends({}, rest, {
1890
+ ref: ref,
1891
+ label: label,
1892
+ onClick: handleAnchorClick,
1893
+ onKeyDown: handleAnchorKeyDown,
1894
+ ariaExpanded: open,
1895
+ disabled: disabled
1896
+ }));
1897
+ useEffect(function () {
1898
+ if (shouldFocusAnchor) {
1899
+ menuAnchorRef.current.focus();
1900
+ }
1901
+ }, [shouldFocusAnchor]);
1902
+ var menuRef = useRef(null);
1903
+ var refs = useMemo(function () {
1904
+ if (parentRefs) {
1905
+ return [].concat(_toConsumableArray(parentRefs), [menuAnchorRef, menuRef]);
1906
+ }
1907
+
1908
+ return [menuAnchorRef, menuRef];
1909
+ }, [parentRefs]);
1910
+ var clickOutsideEnabled = useRef(true);
1911
+ var setClickOutsideEnabled = useCallback(function (isEnabled) {
1912
+ clickOutsideEnabled.current = isEnabled;
1913
+ }, []);
1914
+ useEffect(function () {
1915
+ parentSetClickOutsideEnabled && parentSetClickOutsideEnabled(!open);
1916
+ }, [open, parentSetClickOutsideEnabled]);
1917
+ var handler = React.useCallback(function () {
1918
+ clickOutsideEnabled.current && closeMenu();
1919
+ }, [closeMenu]);
1920
+ useClickOutside(refs, handler);
1921
+
1922
+ var onSelect = parentOnSelect || function () {
1923
+ return closeMenu({
1924
+ shouldFocusAnchor: true
1925
+ });
1926
+ };
1927
+
1928
+ var contextValue = {
1929
+ setClickOutsideEnabled: setClickOutsideEnabled,
1930
+ refs: refs,
1931
+ onSelect: onSelect,
1932
+ focusedIndex: focusedIndex,
1933
+ setFocusedIndex: setFocusedIndex
1934
+ };
1935
+ return React.createElement(Popper, {
1936
+ open: isSubmenu ? !disabled && menuItemIndex === parentFocusedIndex : open,
1937
+ anchor: menuAnchor,
1938
+ anchorRef: menuAnchorRef,
1939
+ portalTarget: portalTarget,
1940
+ placement: isSubmenu ? 'right-start' : placement
1941
+ }, React.createElement("div", {
1942
+ ref: menuRef,
1943
+ role: "menu",
1944
+ tabIndex: "-1",
1945
+ className: styles.menuItemsContainer,
1946
+ onKeyDown: handleMenuKeyDown,
1947
+ onClick: function onClick(e) {
1948
+ return e.nativeEvent.stopImmediatePropagation();
1949
+ }
1950
+ }, React.createElement("div", {
1951
+ style: {
1952
+ maxHeight: maxHeight
1953
+ },
1954
+ className: classNames(styles.menuItems, _defineProperty({}, styles.scrollable, !!maxHeight))
1955
+ }, React.createElement(MenuContextProvider, {
1956
+ value: contextValue
1957
+ }, menuItems))));
1958
+ });
1959
+ Menu.propTypes = {
1960
+ label: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
1961
+ children: PropTypes.node,
1962
+ placement: PropTypes.oneOf(placements),
1963
+ disabled: PropTypes.bool,
1964
+ kind: PropTypes.string,
1965
+ menuItemIndex: PropTypes.number,
1966
+ portalTarget: PropTypes.instanceOf(Element),
1967
+ maxHeight: PropTypes.oneOfType([PropTypes.string, PropTypes.number])
1968
+ };
1969
+ Menu.defaultProps = {
1970
+ label: undefined,
1971
+ children: undefined,
1972
+ placement: 'bottom-start',
1973
+ disabled: undefined,
1974
+ kind: undefined,
1975
+ menuItemIndex: undefined,
1976
+ portalTarget: undefined,
1977
+ maxHeight: undefined
1978
+ };
1979
+
1980
+ var FormField = React.forwardRef(function (props, ref) {
1981
+ var styles = useStyles('FormFieldStyles');
1982
+ var className = props.className,
1983
+ children = props.children,
1984
+ errorText = props.errorText,
1985
+ helperText = props.helperText;
1986
+ return React.createElement("div", {
1987
+ className: className,
1988
+ ref: ref
1989
+ }, children, helperText ? React.createElement(Caption, {
1990
+ className: styles.caption,
1991
+ type: "helper"
1992
+ }, helperText) : null, errorText ? React.createElement(Caption, {
1993
+ className: styles.caption,
1994
+ type: "error"
1995
+ }, errorText) : null);
1996
+ });
1997
+ FormField.propTypes = {
1998
+ className: PropTypes.string,
1999
+ children: PropTypes.any,
2000
+ errorText: PropTypes.string,
2001
+ helperText: PropTypes.string
2002
+ };
2003
+ FormField.defaultProps = {
2004
+ className: null,
2005
+ children: null,
2006
+ errorText: null,
2007
+ helperText: null
2008
+ };
2009
+
2010
+ var TextField = React.forwardRef(function (props, ref) {
2011
+ var styles = useStyles('TextFieldStyles');
2012
+ var ariaLabel = props.ariaLabel,
2013
+ autoComplete = props.autoComplete,
2014
+ className = props.className,
2015
+ disabled = props.disabled,
2016
+ errorText = props.errorText,
2017
+ full = props.full,
2018
+ helperText = props.helperText,
2019
+ id = props.id,
2020
+ invalid = props.invalid,
2021
+ label = props.label,
2022
+ multiline = props.multiline,
2023
+ onBlur = props.onBlur,
2024
+ onChange = props.onChange,
2025
+ placeholder = props.placeholder,
2026
+ rows = props.rows,
2027
+ small = props.small,
2028
+ style = props.style,
2029
+ type = props.type,
2030
+ value = props.value;
2031
+ var classes = classNames(className, styles['text-field'], _defineProperty({}, styles.full, full));
2032
+ var labelClasses = classNames(styles.label, _defineProperty({}, styles.full, full));
2033
+ var InputComponent = React.createElement(Input, {
2034
+ ariaLabel: ariaLabel,
2035
+ autoComplete: autoComplete,
2036
+ disabled: disabled,
2037
+ full: full,
2038
+ id: id,
2039
+ invalid: invalid,
2040
+ multiline: multiline,
2041
+ onBlur: onBlur,
2042
+ onChange: onChange,
2043
+ placeholder: placeholder,
2044
+ ref: ref,
2045
+ rows: rows,
2046
+ small: small,
2047
+ type: type,
2048
+ value: value
2049
+ });
2050
+ return React.createElement(FormField, {
2051
+ className: classes,
2052
+ style: style,
2053
+ helperText: helperText,
2054
+ errorText: errorText
2055
+ }, label ? React.createElement(Label, {
2056
+ htmlFor: id,
2057
+ className: labelClasses
2058
+ }, label, InputComponent) : InputComponent);
2059
+ });
2060
+ TextField.propTypes = {
2061
+ ariaLabel: PropTypes.string,
2062
+ autoComplete: PropTypes.string,
2063
+ className: PropTypes.string,
2064
+ disabled: PropTypes.bool,
2065
+ errorText: PropTypes.string,
2066
+ full: PropTypes.bool,
2067
+ helperText: PropTypes.string,
2068
+ id: PropTypes.string,
2069
+ invalid: PropTypes.bool,
2070
+ label: PropTypes.string,
2071
+ multiline: PropTypes.bool,
2072
+ onBlur: PropTypes.func,
2073
+ onChange: PropTypes.func,
2074
+ placeholder: PropTypes.string,
2075
+ rows: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
2076
+ small: PropTypes.bool,
2077
+ style: PropTypes.object,
2078
+ type: PropTypes.oneOf(InputTypes),
2079
+ value: PropTypes.oneOfType([PropTypes.string, PropTypes.number])
2080
+ };
2081
+ TextField.defaultProps = {
2082
+ ariaLabel: null,
2083
+ autoComplete: null,
2084
+ className: null,
2085
+ disabled: false,
2086
+ errorText: null,
2087
+ full: false,
2088
+ helperText: null,
2089
+ id: null,
2090
+ invalid: false,
2091
+ label: null,
2092
+ multiline: false,
2093
+ onBlur: null,
2094
+ onChange: null,
2095
+ placeholder: null,
2096
+ rows: null,
2097
+ small: false,
2098
+ style: {},
2099
+ type: null,
2100
+ value: undefined
2101
+ };
2102
+
2103
+ var InputGroup = React.forwardRef(function (props, ref) {
2104
+ var styles = useStyles('InputGroupStyles');
2105
+ var children = props.children,
2106
+ className = props.className,
2107
+ full = props.full,
2108
+ small = props.small;
2109
+ return React.createElement("span", {
2110
+ ref: ref,
2111
+ className: classNames(className, styles.inputGroup, _defineProperty({}, styles.full, full))
2112
+ }, React.Children.map(children, function (child) {
2113
+ var _classNames2;
2114
+
2115
+ if (!React.isValidElement(child)) {
2116
+ return null;
2117
+ }
2118
+
2119
+ return React.cloneElement(child, {
2120
+ className: classNames(child.props.className, styles.inputGroupElement, (_classNames2 = {}, _defineProperty(_classNames2, styles.full, full && child.type === Input), _defineProperty(_classNames2, styles.small, small), _classNames2)),
2121
+ full: false,
2122
+ small: small
2123
+ });
2124
+ }));
2125
+ });
2126
+ InputGroup.defaultProps = {
2127
+ children: null,
2128
+ className: null,
2129
+ full: null,
2130
+ small: null
2131
+ };
2132
+ InputGroup.propTypes = {
2133
+ children: PropTypes.any,
2134
+ className: PropTypes.string,
2135
+ full: PropTypes.bool,
2136
+ small: PropTypes.bool
2137
+ };
2138
+
2139
+ var InputGroupAddon = function InputGroupAddon(props) {
2140
+ var styles = useStyles('InputGroupStyles');
2141
+ var children = props.children,
2142
+ className = props.className,
2143
+ small = props.small;
2144
+ return React.createElement("span", {
2145
+ className: classNames(className, styles.addon, _defineProperty({}, styles.small, small))
2146
+ }, children);
2147
+ };
2148
+
2149
+ InputGroupAddon.defaultProps = {
2150
+ children: null,
2151
+ className: null,
2152
+ small: false
2153
+ };
2154
+ InputGroupAddon.propTypes = {
2155
+ children: PropTypes.any,
2156
+ className: PropTypes.string,
2157
+ small: PropTypes.bool
2158
+ };
2159
+
2160
+ var InlineInput = React.forwardRef(function (props, _ref) {
2161
+ var styles = useStyles('InlineInputStyles');
2162
+ var ariaLabel = props.ariaLabel,
2163
+ className = props.className,
2164
+ defaultValue = props.defaultValue,
2165
+ id = props.id,
2166
+ onChange = props.onChange,
2167
+ onBlur = props.onBlur;
2168
+ var internalRef = React.useRef(null);
2169
+
2170
+ var _React$useState = React.useState(defaultValue),
2171
+ _React$useState2 = _slicedToArray(_React$useState, 2),
2172
+ lastVal = _React$useState2[0],
2173
+ setLastVal = _React$useState2[1];
2174
+
2175
+ var changeHandler = function changeHandler(e) {
2176
+ if (typeof onChange === 'function') {
2177
+ var newVal = e.target.innerText;
2178
+
2179
+ if (newVal !== lastVal) {
2180
+ e.target.value = newVal;
2181
+ onChange(e);
2182
+ setLastVal(newVal);
2183
+ }
2184
+ }
2185
+ };
2186
+
2187
+ var blurHandler = function blurHandler(e) {
2188
+ if (typeof onBlur === 'function') {
2189
+ e.target.value = e.target.innerText;
2190
+ onBlur(e);
2191
+ }
2192
+ };
2193
+
2194
+ return React.createElement("span", {
2195
+ "aria-label": ariaLabel,
2196
+ className: classNames(className, styles.inlineInput),
2197
+ contentEditable: true,
2198
+ suppressContentEditableWarning: true,
2199
+ id: id,
2200
+ onBlur: blurHandler,
2201
+ onKeyDown: function onKeyDown(e) {
2202
+ if (e.key === 'Enter' || e.key === 'Escape') {
2203
+ e.preventDefault();
2204
+ internalRef.current.blur();
2205
+ }
2206
+ },
2207
+ onInput: changeHandler,
2208
+ onFocus: function onFocus() {
2209
+ setTimeout(function () {
2210
+ var range = document.createRange();
2211
+ range.selectNodeContents(internalRef.current);
2212
+ var sel = window.getSelection();
2213
+ sel.removeAllRanges();
2214
+ sel.addRange(range);
2215
+ });
2216
+ },
2217
+ ref: function ref(node) {
2218
+ internalRef.current = node;
2219
+ assignRef(_ref, node);
2220
+ },
2221
+ role: "textbox",
2222
+ tabIndex: 0
2223
+ }, defaultValue);
2224
+ });
2225
+ InlineInput.defaultProps = {
2226
+ ariaLabel: null,
2227
+ defaultValue: null,
2228
+ className: null,
2229
+ id: null,
2230
+ onBlur: null,
2231
+ onChange: null
2232
+ };
2233
+ InlineInput.propTypes = {
2234
+ ariaLabel: PropTypes.string,
2235
+ className: PropTypes.string,
2236
+ defaultValue: PropTypes.string,
2237
+ id: PropTypes.string,
2238
+ onBlur: PropTypes.func,
2239
+ onChange: PropTypes.func
2240
+ };
2241
+
2242
+ var Tooltip = React.forwardRef(function Tooltip(_ref, ref) {
2243
+ var content = _ref.content,
2244
+ placement = _ref.placement,
2245
+ children = _ref.children,
2246
+ disabled = _ref.disabled,
2247
+ delayMs = _ref.delayMs,
2248
+ zIndex = _ref.zIndex,
2249
+ className = _ref.className,
2250
+ portalTarget = _ref.portalTarget;
2251
+ var styles = useStyles('TooltipStyles');
2252
+
2253
+ var _useState = useState(false),
2254
+ _useState2 = _slicedToArray(_useState, 2),
2255
+ show = _useState2[0],
2256
+ setShow = _useState2[1];
2257
+
2258
+ var timer;
2259
+
2260
+ function onMouseEnter() {
2261
+ if (!disabled) {
2262
+ timer = setTimeout(function () {
2263
+ return setShow(true);
2264
+ }, delayMs);
2265
+ }
2266
+ }
2267
+
2268
+ function onMouseLeave() {
2269
+ clearTimeout(timer);
2270
+ setShow(false);
2271
+ }
2272
+
2273
+ var anchor = React.cloneElement(children, {
2274
+ onMouseEnter: onMouseEnter,
2275
+ onMouseLeave: onMouseLeave
2276
+ });
2277
+ var tooltipClasses = classNames(styles.tooltip, className);
2278
+ return React.createElement(Popper, {
2279
+ open: show,
2280
+ anchor: anchor,
2281
+ portalTarget: portalTarget,
2282
+ placement: placement,
2283
+ popperRef: ref
2284
+ }, function (_ref2) {
2285
+ var ref = _ref2.ref,
2286
+ style = _ref2.style,
2287
+ placement = _ref2.placement,
2288
+ arrowProps = _ref2.arrowProps;
2289
+ return React.createElement("div", {
2290
+ className: tooltipClasses,
2291
+ ref: ref,
2292
+ style: _objectSpread2({}, style, {
2293
+ zIndex: zIndex
2294
+ }),
2295
+ "data-placement": placement
2296
+ }, content, React.createElement("div", {
2297
+ className: "".concat(styles.arrow),
2298
+ ref: arrowProps.ref,
2299
+ style: _objectSpread2({}, arrowProps.style)
2300
+ }));
2301
+ });
2302
+ });
2303
+ Tooltip.propTypes = {
2304
+ children: PropTypes.element.isRequired,
2305
+ content: PropTypes.element,
2306
+ placement: PropTypes.oneOf(placements),
2307
+ delayMs: PropTypes.number,
2308
+ zIndex: PropTypes.number,
2309
+ disabled: PropTypes.bool,
2310
+ portalTarget: PropTypes.instanceOf(Element),
2311
+ className: PropTypes.string
2312
+ };
2313
+ Tooltip.defaultProps = {
2314
+ content: undefined,
2315
+ placement: 'top',
2316
+ delayMs: 0,
2317
+ zIndex: 2000,
2318
+ disabled: false,
2319
+ portalTarget: undefined,
2320
+ className: undefined
2321
+ };
2322
+
2323
+ var Popover = React.forwardRef(function Popover(_ref, ref) {
2324
+ var show = _ref.show,
2325
+ content = _ref.content,
2326
+ placement = _ref.placement,
2327
+ anchor = _ref.children,
2328
+ zIndex = _ref.zIndex,
2329
+ className = _ref.className,
2330
+ portalTarget = _ref.portalTarget;
2331
+ var styles = useStyles('PopoverStyles');
2332
+ var classes = classNames(styles.popover, className);
2333
+ return React.createElement(Popper, {
2334
+ open: show,
2335
+ anchor: anchor,
2336
+ portalTarget: portalTarget,
2337
+ placement: placement,
2338
+ popperRef: ref
2339
+ }, function (_ref2) {
2340
+ var ref = _ref2.ref,
2341
+ style = _ref2.style,
2342
+ placement = _ref2.placement,
2343
+ arrowProps = _ref2.arrowProps;
2344
+ return React.createElement("div", {
2345
+ className: classes,
2346
+ ref: ref,
2347
+ style: _objectSpread2({}, style, {
2348
+ zIndex: zIndex
2349
+ }),
2350
+ "data-placement": placement
2351
+ }, content, React.createElement("div", {
2352
+ className: "".concat(styles.arrow),
2353
+ ref: arrowProps.ref,
2354
+ style: _objectSpread2({}, arrowProps.style)
2355
+ }));
2356
+ });
2357
+ });
2358
+ Popover.propTypes = {
2359
+ children: PropTypes.element.isRequired,
2360
+ content: PropTypes.element,
2361
+ show: PropTypes.bool,
2362
+ placement: PropTypes.oneOf(placements),
2363
+ zIndex: PropTypes.number,
2364
+ portalTarget: PropTypes.instanceOf(Element),
2365
+ className: PropTypes.string
2366
+ };
2367
+ Popover.defaultProps = {
2368
+ content: undefined,
2369
+ show: false,
2370
+ placement: 'top',
2371
+ zIndex: 1000,
2372
+ portalTarget: undefined,
2373
+ className: undefined
2374
+ };
2375
+
2376
+ var ButtonGroup = React.forwardRef(function ButtonGroup(props, ref) {
2377
+ var styles = useStyles('ButtonGroupStyles');
2378
+ var children = props.children,
2379
+ className = props.className,
2380
+ full = props.full,
2381
+ small = props.small;
2382
+ var contextValue = React.useMemo(function () {
2383
+ return {
2384
+ isInsideButtonGroup: true,
2385
+ full: full,
2386
+ small: small
2387
+ };
2388
+ }, [full, small]);
2389
+ return React.createElement("span", {
2390
+ ref: ref,
2391
+ className: classNames(className, styles.buttonGroup, _defineProperty({}, styles.full, full))
2392
+ }, React.createElement(ButtonGroupContextProvider, {
2393
+ value: contextValue
2394
+ }, children));
2395
+ });
2396
+ ButtonGroup.defaultProps = {
2397
+ children: null,
2398
+ className: null,
2399
+ full: null,
2400
+ small: null
2401
+ };
2402
+ ButtonGroup.propTypes = {
2403
+ children: PropTypes.any,
2404
+ className: PropTypes.string,
2405
+ full: PropTypes.bool,
2406
+ small: PropTypes.bool
2407
+ };
2408
+
2409
+ var backgrounds = ['hide', 'fade', 'show'];
2410
+ var sizes = ['small', 'medium', 'large'];
2411
+ var Spinner = React.forwardRef(function Spinner(props, ref) {
2412
+ var styles = useStyles('SpinnerStyles');
2413
+
2414
+ var background = props.background,
2415
+ children = props.children,
2416
+ className = props.className,
2417
+ id = props.id,
2418
+ inverted = props.inverted,
2419
+ show = props.show,
2420
+ size = props.size,
2421
+ style = props.style,
2422
+ testId = props.testId,
2423
+ other = _objectWithoutProperties(props, ["background", "children", "className", "id", "inverted", "show", "size", "style", "testId"]);
2424
+
2425
+ return React.createElement("div", _extends({
2426
+ ref: ref,
2427
+ id: id,
2428
+ style: style,
2429
+ className: classNames(styles.spinnerContainer, _defineProperty({}, styles[size], !children)),
2430
+ "data-testid": testId
2431
+ }, other), show && React.createElement("div", {
2432
+ className: classNames(styles.spinnerComponent, styles[size], _defineProperty({}, styles.inverted, inverted))
2433
+ }, React.createElement("div", null, React.createElement("div", null), React.createElement("div", null), React.createElement("div", null), React.createElement("div", null), React.createElement("div", null), React.createElement("div", null), React.createElement("div", null), React.createElement("div", null), React.createElement("div", null))), React.createElement("div", {
2434
+ className: classNames(styles.spinnerContent, _defineProperty({}, styles[background], show))
2435
+ }, children));
2436
+ });
2437
+ Spinner.propTypes = {
2438
+ background: PropTypes.oneOf(backgrounds),
2439
+ children: PropTypes.oneOfType([PropTypes.element, PropTypes.string]),
2440
+ className: PropTypes.string,
2441
+ id: PropTypes.string,
2442
+ inverted: PropTypes.bool,
2443
+ show: PropTypes.bool,
2444
+ size: PropTypes.oneOf(sizes),
2445
+ style: PropTypes.object,
2446
+ testId: PropTypes.string
2447
+ };
2448
+ Spinner.defaultProps = {
2449
+ background: 'fade',
2450
+ children: undefined,
2451
+ className: undefined,
2452
+ id: undefined,
2453
+ inverted: false,
2454
+ show: false,
2455
+ size: 'medium',
2456
+ style: undefined,
2457
+ testId: undefined
2458
+ };
2459
+
2460
+ function createStyledComponent(displayName, stylesNamespace, className) {
2461
+ var NewComponent = React.forwardRef(function (_ref, ref) {
2462
+ var children = _ref.children,
2463
+ userClassname = _ref.className,
2464
+ testId = _ref.testId,
2465
+ restProps = _objectWithoutProperties(_ref, ["children", "className", "testId"]);
2466
+
2467
+ var styles = useStyles(stylesNamespace);
2468
+ var classes = classNames(styles[className], userClassname);
2469
+ return React.createElement("div", _extends({
2470
+ ref: ref,
2471
+ "data-testid": testId,
2472
+ className: classes
2473
+ }, restProps), children);
2474
+ });
2475
+ NewComponent.displayName = displayName;
2476
+ NewComponent.propTypes = {
2477
+ className: PropTypes.string,
2478
+ children: PropTypes.any,
2479
+ testId: PropTypes.string
2480
+ };
2481
+ NewComponent.defaultProps = {
2482
+ className: undefined,
2483
+ children: undefined,
2484
+ testId: undefined
2485
+ };
2486
+ return NewComponent;
2487
+ }
2488
+
2489
+ var Modal = function Modal(_ref) {
2490
+ var open = _ref.open,
2491
+ children = _ref.children,
2492
+ zIndex = _ref.zIndex,
2493
+ portalTarget = _ref.portalTarget,
2494
+ testId = _ref.testId,
2495
+ restProps = _objectWithoutProperties(_ref, ["open", "children", "zIndex", "portalTarget", "testId"]);
2496
+
2497
+ var _React$useState = React.useState(open),
2498
+ _React$useState2 = _slicedToArray(_React$useState, 2),
2499
+ isInDOM = _React$useState2[0],
2500
+ setIsInDOM = _React$useState2[1];
2501
+
2502
+ useEffect(function () {
2503
+ open && setIsInDOM(true);
2504
+ }, [open]);
2505
+ return isInDOM && React.createElement(Portal, {
2506
+ portalTarget: portalTarget
2507
+ }, React.createElement(Overlay, {
2508
+ open: open,
2509
+ zIndex: zIndex,
2510
+ onAnimationEnd: function onAnimationEnd() {
2511
+ return !open && setIsInDOM(false);
2512
+ }
2513
+ }, React.createElement(Dialog, _extends({
2514
+ open: open,
2515
+ testId: testId
2516
+ }, restProps), children)));
2517
+ };
2518
+
2519
+ Modal.propTypes = {
2520
+ open: PropTypes.bool,
2521
+ className: PropTypes.string,
2522
+ children: PropTypes.any,
2523
+ zIndex: PropTypes.number,
2524
+ portalTarget: PropTypes.instanceOf(Element),
2525
+ testId: PropTypes.string
2526
+ };
2527
+ Modal.defaultProps = {
2528
+ open: false,
2529
+ className: undefined,
2530
+ children: undefined,
2531
+ zIndex: 1050,
2532
+ portalTarget: undefined,
2533
+ testId: undefined
2534
+ };
2535
+
2536
+ var Overlay = function Overlay(_ref2) {
2537
+ var _classNames;
2538
+
2539
+ var open = _ref2.open,
2540
+ zIndex = _ref2.zIndex,
2541
+ children = _ref2.children,
2542
+ onAnimationEnd = _ref2.onAnimationEnd;
2543
+ var styles = useStyles('ModalStyles');
2544
+ var overlayClasses = classNames(styles.backdrop, (_classNames = {}, _defineProperty(_classNames, styles.fadeEnter, open), _defineProperty(_classNames, styles.fadeLeave, !open), _classNames));
2545
+ return React.createElement("div", {
2546
+ className: overlayClasses,
2547
+ onAnimationEnd: onAnimationEnd,
2548
+ style: {
2549
+ zIndex: zIndex
2550
+ }
2551
+ }, children, React.createElement("style", null, "body { overflow: hidden; }"));
2552
+ };
2553
+
2554
+ Overlay.propTypes = {
2555
+ open: PropTypes.bool,
2556
+ zIndex: PropTypes.number,
2557
+ children: PropTypes.any,
2558
+ onAnimationEnd: PropTypes.func
2559
+ };
2560
+ Overlay.defaultProps = {
2561
+ open: false,
2562
+ zIndex: undefined,
2563
+ children: undefined,
2564
+ onAnimationEnd: undefined
2565
+ };
2566
+
2567
+ var Dialog = function Dialog(_ref3) {
2568
+ var _classNames2;
2569
+
2570
+ var open = _ref3.open,
2571
+ children = _ref3.children,
2572
+ className = _ref3.className,
2573
+ testId = _ref3.testId,
2574
+ restProps = _objectWithoutProperties(_ref3, ["open", "children", "className", "testId"]);
2575
+
2576
+ var styles = useStyles('ModalStyles');
2577
+ var modalClasses = classNames(styles.modal, className, (_classNames2 = {}, _defineProperty(_classNames2, styles.zoomEnter, open), _defineProperty(_classNames2, styles.zoomLeave, !open), _classNames2));
2578
+ return React.createElement("div", _extends({
2579
+ className: modalClasses,
2580
+ "data-testid": testId
2581
+ }, restProps), children);
2582
+ };
2583
+
2584
+ Dialog.propTypes = {
2585
+ open: PropTypes.bool,
2586
+ className: PropTypes.string,
2587
+ children: PropTypes.any,
2588
+ testId: PropTypes.string
2589
+ };
2590
+ Dialog.defaultProps = {
2591
+ open: false,
2592
+ className: undefined,
2593
+ children: undefined,
2594
+ testId: undefined
2595
+ };
2596
+ var ModalHeader = createStyledComponent('ModalHeader', 'ModalStyles', 'modalHeader');
2597
+ var ModalBody = createStyledComponent('ModalBody', 'ModalStyles', 'modalBody');
2598
+ var ModalFooter = createStyledComponent('ModalFooter', 'ModalStyles', 'modalFooter');
2599
+
2600
+ function UIProvider(_ref) {
2601
+ var children = _ref.children;
2602
+ var styleOverrides = useMemo(function () {
2603
+ return getStyleOverridesStore();
2604
+ }, []);
2605
+
2606
+ var _useState = useState(function () {
2607
+ // use styles overrides if available, otherwise use built-in styles
2608
+ return styleOverrides.get() || styles;
2609
+ }),
2610
+ _useState2 = _slicedToArray(_useState, 2),
2611
+ styles$1 = _useState2[0],
2612
+ setStyles = _useState2[1]; // subscribe to changes to styles overrides
2613
+
2614
+
2615
+ useEffect(function () {
2616
+ var unsubscribe = styleOverrides.subscribe(function () {
2617
+ setStyles(styleOverrides.get() || styles);
2618
+ });
2619
+ return function () {
2620
+ return unsubscribe();
2621
+ };
2622
+ }, [styleOverrides]);
2623
+ return React.createElement(UIContext.Provider, {
2624
+ value: styles$1
2625
+ }, children);
2626
+ }
2627
+
2628
+ UIProvider.propTypes = {
2629
+ children: PropTypes.any
2630
+ };
2631
+ UIProvider.defaultProps = {
2632
+ children: undefined
2633
+ };
2634
+
2635
+ export { Button, ButtonGroup, Caption, Checkbox, FilePicker, FormField, Icon, IconTypes, InlineInput, Input, InputGroup, InputGroupAddon, Label, Link, Menu, MenuItem, Modal, ModalBody, ModalFooter, ModalHeader, Popover, Radio, RadioGroup, SelectMenu, Spinner, Switch, Tab, Table, TableBody, TableCell, TableHead, TableHeaderCell, TableRow, Tabs, TextField, Tooltip, UIProvider, version };