@carbon/react 0.17.0-rc.0 → 1.0.0

package/es/internal/OptimizedResize.js

@@ -0,0 +1,65 @@
+/**
+ * Copyright IBM Corp. 2016, 2021
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import window from 'window-or-global';
+
+// mdn resize function
+
+var OptimizedResize = function optimizedResize() {
+  var callbacks = [];
+  var running = false; // run the actual callbacks
+
+  function runCallbacks() {
+    callbacks.forEach(function (callback) {
+      callback();
+    });
+    running = false;
+  } // fired on resize event
+
+
+  function resize() {
+    if (!running) {
+      running = true;
+      window.requestAnimationFrame(runCallbacks);
+    }
+  } // adds callback to loop
+
+
+  function addCallback(callback) {
+    if (callback) {
+      var index = callbacks.indexOf(callback);
+
+      if (index < 0) {
+        callbacks.push(callback);
+      }
+    }
+  }
+
+  return {
+    // public method to add additional callback
+    add: function add(callback) {
+      if (!callbacks.length) {
+        window.addEventListener('resize', resize);
+      }
+
+      addCallback(callback);
+      return {
+        release: function release() {
+          var index = callbacks.indexOf(callback);
+
+          if (index >= 0) {
+            callbacks.splice(index, 1);
+          }
+        }
+      };
+    }
+  };
+}();
+
+var OptimizedResize$1 = OptimizedResize;
+
+export { OptimizedResize$1 as default };

package/es/internal/Selection.js

@@ -0,0 +1,243 @@
+/**
+ * Copyright IBM Corp. 2016, 2021
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { slicedToArray as _slicedToArray, inherits as _inherits, createSuper as _createSuper, classCallCheck as _classCallCheck, defineProperty as _defineProperty, assertThisInitialized as _assertThisInitialized, createClass as _createClass } from '../_virtual/_rollupPluginBabelHelpers.js';
+import React__default, { useRef, useState, useCallback, useEffect } from 'react';
+import PropTypes from 'prop-types';
+import isEqual from 'lodash.isequal';
+
+function callOnChangeHandler(_ref) {
+  var isControlled = _ref.isControlled,
+      isMounted = _ref.isMounted,
+      onChangeHandlerControlled = _ref.onChangeHandlerControlled,
+      onChangeHandlerUncontrolled = _ref.onChangeHandlerUncontrolled,
+      selectedItems = _ref.selectedItems;
+
+  if (isControlled) {
+    if (isMounted && onChangeHandlerControlled) {
+      onChangeHandlerControlled({
+        selectedItems: selectedItems
+      });
+    }
+  } else {
+    onChangeHandlerUncontrolled(selectedItems);
+  }
+}
+
+function useSelection(_ref2) {
+  var disabled = _ref2.disabled,
+      onChange = _ref2.onChange,
+      _ref2$initialSelected = _ref2.initialSelectedItems,
+      initialSelectedItems = _ref2$initialSelected === void 0 ? [] : _ref2$initialSelected,
+      controlledItems = _ref2.selectedItems;
+  var isMounted = useRef(false);
+  var savedOnChange = useRef(onChange);
+
+  var _useState = useState(initialSelectedItems),
+      _useState2 = _slicedToArray(_useState, 2),
+      uncontrolledItems = _useState2[0],
+      setUncontrolledItems = _useState2[1];
+
+  var isControlled = !!controlledItems;
+  var selectedItems = isControlled ? controlledItems : uncontrolledItems;
+  var onItemChange = useCallback(function (item) {
+    if (disabled) {
+      return;
+    }
+
+    var selectedIndex;
+    selectedItems.forEach(function (selectedItem, index) {
+      if (isEqual(selectedItem, item)) {
+        selectedIndex = index;
+      }
+    });
+    var newSelectedItems;
+
+    if (selectedIndex === undefined) {
+      newSelectedItems = selectedItems.concat(item);
+      callOnChangeHandler({
+        isControlled: isControlled,
+        isMounted: isMounted.current,
+        onChangeHandlerControlled: savedOnChange.current,
+        onChangeHandlerUncontrolled: setUncontrolledItems,
+        selectedItems: newSelectedItems
+      });
+      return;
+    }
+
+    newSelectedItems = removeAtIndex(selectedItems, selectedIndex);
+    callOnChangeHandler({
+      isControlled: isControlled,
+      isMounted: isMounted.current,
+      onChangeHandlerControlled: savedOnChange.current,
+      onChangeHandlerUncontrolled: setUncontrolledItems,
+      selectedItems: newSelectedItems
+    });
+  }, [disabled, isControlled, selectedItems]);
+  var clearSelection = useCallback(function () {
+    if (disabled) {
+      return;
+    }
+
+    callOnChangeHandler({
+      isControlled: isControlled,
+      isMounted: isMounted.current,
+      onChangeHandlerControlled: savedOnChange.current,
+      onChangeHandlerUncontrolled: setUncontrolledItems,
+      selectedItems: []
+    });
+  }, [disabled, isControlled]);
+  useEffect(function () {
+    savedOnChange.current = onChange;
+  }, [onChange]);
+  useEffect(function () {
+    if (isMounted.current && savedOnChange.current && !isControlled) {
+      savedOnChange.current({
+        selectedItems: selectedItems
+      });
+    }
+  }, [isControlled, selectedItems]);
+  useEffect(function () {
+    isMounted.current = true;
+    return function () {
+      isMounted.current = false;
+    };
+  }, []);
+  return {
+    selectedItems: selectedItems,
+    onItemChange: onItemChange,
+    clearSelection: clearSelection
+  };
+}
+
+var Selection = /*#__PURE__*/function (_React$Component) {
+  _inherits(Selection, _React$Component);
+
+  var _super = _createSuper(Selection);
+
+  function Selection(props) {
+    var _this;
+
+    _classCallCheck(this, Selection);
+
+    _this = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this), "internalSetState", function (stateToSet, callback) {
+      return _this.setState(stateToSet, function () {
+        if (callback) {
+          callback();
+        }
+
+        if (_this.props.onChange) {
+          _this.props.onChange(_this.state);
+        }
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleClearSelection", function () {
+      if (_this.props.disabled) {
+        return;
+      }
+
+      _this.internalSetState({
+        selectedItems: []
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleSelectItem", function (item) {
+      _this.internalSetState(function (state) {
+        return {
+          selectedItems: state.selectedItems.concat(item)
+        };
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleRemoveItem", function (index) {
+      _this.internalSetState(function (state) {
+        return {
+          selectedItems: removeAtIndex(state.selectedItems, index)
+        };
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleOnItemChange", function (item) {
+      if (_this.props.disabled) {
+        return;
+      }
+
+      var selectedItems = _this.state.selectedItems;
+      var selectedIndex;
+      selectedItems.forEach(function (selectedItem, index) {
+        if (isEqual(selectedItem, item)) {
+          selectedIndex = index;
+        }
+      });
+
+      if (selectedIndex === undefined) {
+        _this.handleSelectItem(item);
+
+        return;
+      }
+
+      _this.handleRemoveItem(selectedIndex);
+    });
+
+    _this.state = {
+      selectedItems: props.initialSelectedItems
+    };
+    return _this;
+  }
+
+  _createClass(Selection, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+          children = _this$props.children,
+          render = _this$props.render;
+      var selectedItems = this.state.selectedItems;
+      var renderProps = {
+        selectedItems: selectedItems,
+        onItemChange: this.handleOnItemChange,
+        clearSelection: this.handleClearSelection
+      };
+
+      if (render !== undefined) {
+        return render(renderProps);
+      }
+
+      if (children !== undefined) {
+        return children(renderProps);
+      }
+
+      return null;
+    }
+  }]);
+
+  return Selection;
+}(React__default.Component); // Generic utility for safely removing an element at a given index from an
+// array.
+
+
+_defineProperty(Selection, "propTypes", {
+  children: PropTypes.func,
+  disabled: PropTypes.bool,
+  initialSelectedItems: PropTypes.array.isRequired,
+  onChange: PropTypes.func,
+  render: PropTypes.func
+});
+
+_defineProperty(Selection, "defaultProps", {
+  initialSelectedItems: []
+});
+
+var removeAtIndex = function removeAtIndex(array, index) {
+  var result = array.slice();
+  result.splice(index, 1);
+  return result;
+};
+
+export { Selection as default, useSelection };

package/es/internal/createClassWrapper.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright IBM Corp. 2016, 2021
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import React__default from 'react';
+
+/**
+ * Wrap a class component with a functional component. This prevents an end-user
+ * from being able to pass `ref` and access the underlying class instance.
+ *
+ * @param {ReactNode} Component
+ * @returns {ReactNode}
+ */
+
+function createClassWrapper(Component) {
+  function ClassWrapper(props) {
+    return /*#__PURE__*/React__default.createElement(Component, props);
+  }
+
+  if (process.env.NODE_ENV !== "production") {
+    var name = Component.displayName || Component.name;
+    ClassWrapper.displayName = "ClassWrapper(".concat(name, ")");
+  }
+
+  return ClassWrapper;
+}
+
+export { createClassWrapper };

package/es/internal/deprecateFieldOnObject.js

@@ -0,0 +1,26 @@
+/**
+ * Copyright IBM Corp. 2016, 2021
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { warning } from './warning.js';
+
+var didWarnAboutDeprecation = {};
+
+function deprecateFieldOnObject(object, field, Component, message) {
+  Object.defineProperty(object, field, {
+    enumerable: true,
+    get: function get() {
+      if (!didWarnAboutDeprecation[field]) {
+        process.env.NODE_ENV !== "production" ? warning(false, message || "The ".concat(field, " field has been deprecated on the ").concat(object.displayName, " object. ") + "Please import and use ".concat(Component.displayName || Component.name || 'the field', " directly.")) : void 0;
+        didWarnAboutDeprecation[field] = true;
+      }
+
+      return Component;
+    }
+  });
+}
+
+export { deprecateFieldOnObject };

package/es/internal/environment.js

@@ -0,0 +1,15 @@
+/**
+ * Copyright IBM Corp. 2016, 2021
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * Indicate whether current execution environment can access the DOM.
+ *
+ * @see https://github.com/facebook/fbjs/blob/4d1751311d3f67af2dcce2e40df8512a23c7b9c6/packages/fbjs/src/core/ExecutionEnvironment.js#L12
+ */
+var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+
+export { canUseDOM };

package/es/internal/focus/index.js

@@ -0,0 +1,16 @@
+/**
+ * Copyright IBM Corp. 2016, 2021
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+function focus(elementOrRef) {
+  var element = elementOrRef.current || elementOrRef;
+
+  if (element && element.focus && document.activeElement !== element) {
+    element.focus();
+  }
+}
+
+export { focus };

package/es/internal/keyboard/keys.js

@@ -0,0 +1,65 @@
+/**
+ * Copyright IBM Corp. 2016, 2021
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var Tab = {
+  key: 'Tab',
+  which: 9,
+  keyCode: 9
+};
+var Enter = {
+  key: 'Enter',
+  which: 13,
+  keyCode: 13
+};
+var Escape = {
+  key: ['Escape', // IE11 Escape
+  'Esc'],
+  which: 27,
+  keyCode: 27
+};
+var Space = {
+  key: ' ',
+  which: 32,
+  keyCode: 32
+};
+var End = {
+  key: 'End',
+  which: 35,
+  keyCode: 35
+};
+var Home = {
+  key: 'Home',
+  which: 36,
+  keyCode: 36
+};
+var ArrowLeft = {
+  key: 'ArrowLeft',
+  which: 37,
+  keyCode: 37
+};
+var ArrowUp = {
+  key: 'ArrowUp',
+  which: 38,
+  keyCode: 38
+};
+var ArrowRight = {
+  key: 'ArrowRight',
+  which: 39,
+  keyCode: 39
+};
+var ArrowDown = {
+  key: 'ArrowDown',
+  which: 40,
+  keyCode: 40
+};
+var Delete = {
+  key: 'Delete',
+  which: 8 ,
+  keyCode: 8 
+};
+
+export { ArrowDown, ArrowLeft, ArrowRight, ArrowUp, Delete, End, Enter, Escape, Home, Space, Tab };

package/es/internal/keyboard/match.js

@@ -0,0 +1,82 @@
+/**
+ * Copyright IBM Corp. 2016, 2021
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @typedef Key
+ * @property key {Array<string>|string}
+ * @property which {number}
+ * @property keyCode {number}
+ */
+
+/**
+ * Check to see if at least one key code matches the key code of the
+ * given event.
+ *
+ * @example
+ * import * as keys from '../keys';
+ * import { matches } from '../match';
+ *
+ * function handleOnKeyDown(event) {
+ *   if (matches(event, [keys.Enter, keys.Space]) {
+ *     // ...
+ *   }
+ * }
+ *
+ * @param {Event} event
+ * @param {Array<Key>} keysToMatch
+ * @returns {boolean}
+ */
+function matches(event, keysToMatch) {
+  for (var i = 0; i < keysToMatch.length; i++) {
+    if (match(event, keysToMatch[i])) {
+      return true;
+    }
+  }
+
+  return false;
+}
+/**
+ * Check to see if the given key matches the corresponding keyboard event. Also
+ * supports passing in the value directly if you can't used the given event.
+ *
+ * @example
+ * import * as keys from '../keys';
+ * import { matches } from '../match';
+ *
+ * function handleOnKeyDown(event) {
+ *   if (match(event, keys.Enter) {
+ *     // ...
+ *   }
+ * }
+ *
+ * @param {Event|number|string} eventOrCode
+ * @param {Key} key
+ * @returns {boolean}
+ */
+
+function match(eventOrCode) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      key = _ref.key,
+      which = _ref.which,
+      keyCode = _ref.keyCode;
+
+  if (typeof eventOrCode === 'string') {
+    return eventOrCode === key;
+  }
+
+  if (typeof eventOrCode === 'number') {
+    return eventOrCode === which || eventOrCode === keyCode;
+  }
+
+  if (eventOrCode.key && Array.isArray(key)) {
+    return key.indexOf(eventOrCode.key) !== -1;
+  }
+
+  return eventOrCode.key === key || eventOrCode.which === which || eventOrCode.keyCode === keyCode;
+}
+
+export { match, matches };

package/es/internal/keyboard/navigation.js

@@ -0,0 +1,61 @@
+/**
+ * Copyright IBM Corp. 2016, 2021
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { ArrowRight, ArrowLeft } from './keys.js';
+import { match } from './match.js';
+
+/**
+ * Various utilities to help with a11y work
+ */
+
+/**
+ * A "ring buffer" function that takes an array and depending on an ArrowRight
+ * or ArrowLeft key input loops from last index to first or first index to last.
+ *
+ * @param {string} key - the left or right arrow keys
+ * @param {number} index - the current index in a given array
+ * @param {number} arrayLength - the total length of the array
+ *
+ * @example
+ * 	getNextIndex(keyCodes.RIGHT, 0, 4)
+ */
+
+var getNextIndex = function getNextIndex(key, index, arrayLength) {
+  if (match(key, ArrowRight)) {
+    return (index + 1) % arrayLength;
+  }
+
+  if (match(key, ArrowLeft)) {
+    return (index + arrayLength - 1) % arrayLength;
+  }
+};
+/**
+ * A flag `node.compareDocumentPosition(target)` returns,
+ * that indicates `target` is located earlier than `node` in the document or `target` contains `node`.
+ */
+
+var DOCUMENT_POSITION_BROAD_PRECEDING = // Checks `typeof Node` for `react-docgen`
+typeof Node !== 'undefined' && Node.DOCUMENT_POSITION_PRECEDING | Node.DOCUMENT_POSITION_CONTAINS;
+/**
+ * A flag `node.compareDocumentPosition(target)` returns,
+ * that indicates `target` is located later than `node` in the document or `node` contains `target`.
+ */
+
+var DOCUMENT_POSITION_BROAD_FOLLOWING = // Checks `typeof Node` for `react-docgen`
+typeof Node !== 'undefined' && Node.DOCUMENT_POSITION_FOLLOWING | Node.DOCUMENT_POSITION_CONTAINED_BY;
+/**
+ * CSS selector that selects major nodes that are sequential-focusable.
+ */
+
+var selectorTabbable = "\n  a[href], area[href], input:not([disabled]):not([tabindex='-1']),\n  button:not([disabled]):not([tabindex='-1']),select:not([disabled]):not([tabindex='-1']),\n  textarea:not([disabled]):not([tabindex='-1']),\n  iframe, object, embed, *[tabindex]:not([tabindex='-1']):not([disabled]), *[contenteditable=true]\n";
+/**
+ * CSS selector that selects major nodes that are click focusable
+ */
+
+var selectorFocusable = "\n  a[href], area[href], input:not([disabled]),\n  button:not([disabled]),select:not([disabled]),\n  textarea:not([disabled]),\n  iframe, object, embed, *[tabindex]:not([disabled]), *[contenteditable=true]\n";
+
+export { DOCUMENT_POSITION_BROAD_FOLLOWING, DOCUMENT_POSITION_BROAD_PRECEDING, getNextIndex, selectorFocusable, selectorTabbable };

package/es/internal/useControllableState.js

@@ -0,0 +1,86 @@
+/**
+ * Copyright IBM Corp. 2016, 2021
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { useState, useRef, useEffect } from 'react';
+import { warning } from './warning.js';
+
+/**
+ * This custom hook simplifies the behavior of a component if it has state that
+ * can be both controlled and uncontrolled. It functions identical to a
+ * useState() hook and provides [state, setState] for you to use. You can use
+ * the `onChange` argument to allow updates to the `state` to be communicated to
+ * owners of controlled components.
+ *
+ * Note: this hook will warn if a component is switching from controlled to
+ * uncontrolled, or vice-verse.
+ *
+ * @param {object} config
+ * @param {string} config.name - the name of the custom component
+ * @param {any} config.defaultValue - the default value used for the state. This will be
+ * the fallback value used if `value` is not defined.
+ * @param {Function} config.onChange - an optional function that is called when
+ * the value of the state changes. This is useful for communicating to parents of
+ * controlled components that the value is requesting to be changed.
+ * @param {any} config.value - a controlled value. Omitting this means that the state is
+ * uncontrolled
+ * @returns {[any, Function]}
+ */
+
+function useControllableState(_ref) {
+  var defaultValue = _ref.defaultValue,
+      _ref$name = _ref.name,
+      name = _ref$name === void 0 ? 'custom' : _ref$name,
+      onChange = _ref.onChange,
+      value = _ref.value;
+
+  var _useState = useState(value !== null && value !== void 0 ? value : defaultValue),
+      _useState2 = _slicedToArray(_useState, 2),
+      state = _useState2[0],
+      internalSetState = _useState2[1];
+
+  var controlled = useRef(null);
+
+  if (controlled.current === null) {
+    controlled.current = value !== undefined;
+  }
+
+  function setState(stateOrUpdater) {
+    var value = typeof stateOrUpdater === 'function' ? stateOrUpdater(state) : stateOrUpdater;
+
+    if (controlled.current === false) {
+      internalSetState(value);
+    }
+
+    if (onChange) {
+      onChange(value);
+    }
+  }
+
+  useEffect(function () {
+    var controlledValue = value !== undefined; // Uncontrolled -> Controlled
+    // If the component prop is uncontrolled, the prop value should be undefined
+
+    if (controlled.current === false && controlledValue) {
+      process.env.NODE_ENV !== "production" ? warning(false, 'A component is changing an uncontrolled %s component to be controlled. ' + 'This is likely caused by the value changing to a defined value ' + 'from undefined. Decide between using a controlled or uncontrolled ' + 'value for the lifetime of the component. ' + 'More info: https://reactjs.org/link/controlled-components', name) : void 0;
+    } // Controlled -> Uncontrolled
+    // If the component prop is controlled, the prop value should be defined
+
+
+    if (controlled.current === true && !controlledValue) {
+      process.env.NODE_ENV !== "production" ? warning(false, 'A component is changing a controlled %s component to be uncontrolled. ' + 'This is likely caused by the value changing to an undefined value ' + 'from a defined one. Decide between using a controlled or ' + 'uncontrolled value for the lifetime of the component. ' + 'More info: https://reactjs.org/link/controlled-components', name) : void 0;
+    }
+  }, [name, value]);
+
+  if (controlled.current === true) {
+    return [value, setState];
+  }
+
+  return [state, setState];
+}
+
+export { useControllableState };