carbon-addons-iot-react 2.98.2 → 2.100.1

package/es/node_modules/carbon-components-react/es/components/ListBox/ListBox.js

@@ -0,0 +1,98 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+import classnames from 'classnames';
+import { settings } from 'carbon-components';
+import { ListBoxType, ListBoxSize } from './ListBoxPropTypes.js';
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+var prefix = settings.prefix;
+
+var handleOnKeyDown = function handleOnKeyDown(event) {
+  if (event.keyCode === 27) {
+    event.stopPropagation();
+  }
+};
+
+var handleClick = function handleClick(event) {
+  event.preventDefault();
+  event.stopPropagation();
+};
+/**
+ * `ListBox` is a generic container component that handles creating the
+ * container class name in response to certain props.
+ */
+
+
+var ListBox = function ListBox(_ref) {
+  var _cx;
+
+  var children = _ref.children,
+      containerClassName = _ref.className,
+      disabled = _ref.disabled,
+      innerRef = _ref.innerRef,
+      type = _ref.type,
+      size = _ref.size,
+      invalid = _ref.invalid,
+      invalidText = _ref.invalidText,
+      light = _ref.light,
+      isOpen = _ref.isOpen,
+      rest = _objectWithoutProperties(_ref, ["children", "className", "disabled", "innerRef", "type", "size", "invalid", "invalidText", "light", "isOpen"]);
+
+  var className = classnames((_cx = {}, _defineProperty(_cx, containerClassName, !!containerClassName), _defineProperty(_cx, "".concat(prefix, "--list-box"), true), _defineProperty(_cx, "".concat(prefix, "--list-box--").concat(size), size), _defineProperty(_cx, "".concat(prefix, "--list-box--inline"), type === 'inline'), _defineProperty(_cx, "".concat(prefix, "--list-box--disabled"), disabled), _defineProperty(_cx, "".concat(prefix, "--list-box--light"), light), _defineProperty(_cx, "".concat(prefix, "--list-box--expanded"), isOpen), _cx));
+  return React.createElement(React.Fragment, null, React.createElement("div", _extends({}, rest, {
+    className: className,
+    ref: innerRef,
+    onKeyDown: handleOnKeyDown,
+    onClick: handleClick,
+    "data-invalid": invalid || undefined
+  }), children), invalid ? React.createElement("div", {
+    className: "".concat(prefix, "--form-requirement")
+  }, invalidText) : null);
+};
+
+ListBox.propTypes = {
+  /**
+   * Provide the contents of your ListBox
+   */
+  children: PropTypes.node,
+
+  /**
+   * Specify a class name to be applied on the containing list box node
+   */
+  className: PropTypes.string,
+
+  /**
+   * `innerRef` hook used for libraries like Downshift that require a reference
+   * on a container node when it is not a native element
+   */
+  innerRef: PropTypes.func.isRequired,
+
+  /**
+   * Specify whether the ListBox is currently disabled
+   */
+  disabled: PropTypes.bool.isRequired,
+
+  /**
+   * Specify the "type" of the ListBox. Currently supports either `default` or
+   * `inline` as an option.
+   */
+  type: ListBoxType.isRequired,
+
+  /**
+   * Specify the size of the ListBox. Currently supports either `sm` or `xl` as an option.
+   */
+  size: ListBoxSize
+};
+ListBox.defaultProps = {
+  innerRef: function innerRef() {},
+  disabled: false,
+  type: 'default'
+};
+
+export default ListBox;

package/es/node_modules/carbon-components-react/es/components/ListBox/ListBoxField.js

@@ -0,0 +1,57 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+import { settings } from 'carbon-components';
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+var prefix = settings.prefix;
+
+/**
+ * `ListBoxField` is responsible for creating the containing node for valid
+ * elements inside of a field. It also provides a11y-related attributes like
+ * `role` to make sure a user can focus the given field.
+ */
+
+var ListBoxField = function ListBoxField(_ref) {
+  var children = _ref.children,
+      id = _ref.id,
+      disabled = _ref.disabled,
+      tabIndex = _ref.tabIndex,
+      rest = _objectWithoutProperties(_ref, ["children", "id", "disabled", "tabIndex"]);
+
+  return React.createElement("div", _extends({
+    role: rest['aria-expanded'] ? 'combobox' : rest.role || 'combobox',
+    "aria-owns": rest['aria-expanded'] && "".concat(id, "__menu") || null,
+    "aria-controls": rest['aria-expanded'] && "".concat(id, "__menu") || null,
+    "aria-haspopup": "listbox",
+    className: "".concat(prefix, "--list-box__field"),
+    tabIndex: !disabled && tabIndex || -1
+  }, rest), children);
+};
+
+ListBoxField.propTypes = {
+  /**
+   * Provide the contents of your ListBoxField
+   */
+  children: PropTypes.node,
+
+  /**
+   * Specify a custom `id`
+   */
+  id: PropTypes.string.isRequired,
+
+  /**
+   * Specify if the parent <ListBox> is disabled
+   */
+  disabled: PropTypes.bool,
+
+  /**
+   * Optional prop to specify the tabIndex of the <ListBox> trigger button
+   */
+  tabIndex: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
+};
+
+export default ListBoxField;

package/es/node_modules/carbon-components-react/es/components/ListBox/ListBoxMenu.js

@@ -0,0 +1,43 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+import { settings } from 'carbon-components';
+import ListBoxMenuItem from './ListBoxMenuItem.js';
+import childrenOfType from '../../prop-types/childrenOfType.js';
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+var prefix = settings.prefix;
+/**
+ * `ListBoxMenu` is a simple container node that isolates the `list-box__menu`
+ * class into a single component. It is also being used to validate given
+ * `children` components.
+ */
+
+var ListBoxMenu = function ListBoxMenu(_ref) {
+  var children = _ref.children,
+      id = _ref.id,
+      rest = _objectWithoutProperties(_ref, ["children", "id"]);
+
+  return React.createElement("div", _extends({
+    id: "".concat(id, "__menu"),
+    className: "".concat(prefix, "--list-box__menu"),
+    role: "listbox"
+  }, rest), children);
+};
+
+ListBoxMenu.propTypes = {
+  /**
+   * Provide the contents of your ListBoxMenu
+   */
+  children: childrenOfType(ListBoxMenuItem),
+
+  /**
+   * Specify a custom `id`
+   */
+  id: PropTypes.string.isRequired
+};
+
+export default ListBoxMenu;

package/es/node_modules/carbon-components-react/es/components/ListBox/ListBoxMenuIcon.js

@@ -0,0 +1,55 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+import classnames from 'classnames';
+import { ChevronDown16 } from '@carbon/icons-react';
+import { settings } from 'carbon-components';
+
+var _defaultTranslations;
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var prefix = settings.prefix;
+var translationIds = {
+  'close.menu': 'close.menu',
+  'open.menu': 'open.menu'
+};
+var defaultTranslations = (_defaultTranslations = {}, _defineProperty(_defaultTranslations, translationIds['close.menu'], 'Close menu'), _defineProperty(_defaultTranslations, translationIds['open.menu'], 'Open menu'), _defaultTranslations);
+/**
+ * `ListBoxMenuIcon` is used to orient the icon up or down depending on the
+ * state of the menu for a given `ListBox`
+ */
+
+var ListBoxMenuIcon = function ListBoxMenuIcon(_ref) {
+  var isOpen = _ref.isOpen,
+      t = _ref.translateWithId;
+  var className = classnames("".concat(prefix, "--list-box__menu-icon"), _defineProperty({}, "".concat(prefix, "--list-box__menu-icon--open"), isOpen));
+  var description = isOpen ? t('close.menu') : t('open.menu');
+  return React.createElement("div", {
+    className: className
+  }, React.createElement(ChevronDown16, {
+    name: "chevron--down",
+    "aria-label": description
+  }, React.createElement("title", null, description)));
+};
+
+ListBoxMenuIcon.propTypes = {
+  /**
+   * Specify whether the menu is currently open, which will influence the
+   * direction of the menu icon
+   */
+  isOpen: PropTypes.bool.isRequired,
+
+  /**
+   * i18n hook used to provide the appropriate description for the given menu
+   * icon. This function takes in an id defined in `translationIds` and should
+   * return a string message for that given message id.
+   */
+  translateWithId: PropTypes.func.isRequired
+};
+ListBoxMenuIcon.defaultProps = {
+  translateWithId: function translateWithId(id) {
+    return defaultTranslations[id];
+  }
+};
+
+export default ListBoxMenuIcon;
+export { translationIds };

package/es/node_modules/carbon-components-react/es/components/ListBox/ListBoxMenuItem.js

@@ -0,0 +1,58 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+import classnames from 'classnames';
+import { settings } from 'carbon-components';
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+var prefix = settings.prefix;
+/**
+ * `ListBoxMenuItem` is a helper component for managing the container class
+ * name, alongside any classes for any corresponding states, for a generic list
+ * box menu item.
+ */
+
+var ListBoxMenuItem = function ListBoxMenuItem(_ref) {
+  var _cx;
+
+  var children = _ref.children,
+      isActive = _ref.isActive,
+      isHighlighted = _ref.isHighlighted,
+      rest = _objectWithoutProperties(_ref, ["children", "isActive", "isHighlighted"]);
+
+  var className = classnames((_cx = {}, _defineProperty(_cx, "".concat(prefix, "--list-box__menu-item"), true), _defineProperty(_cx, "".concat(prefix, "--list-box__menu-item--active"), isActive), _defineProperty(_cx, "".concat(prefix, "--list-box__menu-item--highlighted"), isHighlighted), _cx));
+  return React.createElement("div", _extends({
+    className: className
+  }, rest), React.createElement("div", {
+    className: "".concat(prefix, "--list-box__menu-item__option")
+  }, children));
+};
+
+ListBoxMenuItem.propTypes = {
+  /**
+   * Specify any children nodes that hsould be rendered inside of the ListBox
+   * Menu Item
+   */
+  children: PropTypes.node,
+
+  /**
+   * Specify whether the current menu item is "active".
+   */
+  isActive: PropTypes.bool.isRequired,
+
+  /**
+   * Specify whether the current menu item is "highlighed".
+   */
+  isHighlighted: PropTypes.bool.isRequired
+};
+ListBoxMenuItem.defaultProps = {
+  isActive: false,
+  isHighlighted: false
+};
+
+export default ListBoxMenuItem;

package/es/node_modules/carbon-components-react/es/components/ListBox/ListBoxPropTypes.js

@@ -0,0 +1,12 @@
+import PropTypes from 'prop-types';
+
+/**
+ * Copyright IBM Corp. 2016, 2018
+ *
+ * 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 ListBoxType = PropTypes.oneOf(['default', 'inline']);
+var ListBoxSize = PropTypes.oneOf(['sm', 'xl']);
+
+export { ListBoxType, ListBoxSize };

package/es/node_modules/carbon-components-react/es/components/ListBox/ListBoxSelection.js

@@ -0,0 +1,96 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+import classnames from 'classnames';
+import { Close16 } from '@carbon/icons-react';
+import { settings } from 'carbon-components';
+import { Enter } from '../../internal/keyboard/keys.js';
+import { match } from '../../internal/keyboard/match.js';
+import '../../internal/keyboard/navigation.js';
+
+var _defaultTranslations;
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var prefix = settings.prefix;
+/**
+ * `ListBoxSelection` is used to provide controls for clearing a selection, in
+ * addition to conditionally rendering a badge if the control has more than one
+ * selection.
+ */
+
+var ListBoxSelection = function ListBoxSelection(_ref) {
+  var _cx;
+
+  var clearSelection = _ref.clearSelection,
+      selectionCount = _ref.selectionCount,
+      t = _ref.translateWithId,
+      disabled = _ref.disabled;
+  var className = classnames("".concat(prefix, "--list-box__selection"), (_cx = {}, _defineProperty(_cx, "".concat(prefix, "--tag--filter"), selectionCount), _defineProperty(_cx, "".concat(prefix, "--list-box__selection--multi"), selectionCount), _cx));
+
+  var handleOnClick = function handleOnClick(event) {
+    event.stopPropagation();
+
+    if (disabled) {
+      return;
+    }
+
+    clearSelection(event);
+  };
+
+  var handleOnKeyDown = function handleOnKeyDown(event) {
+    event.stopPropagation();
+
+    if (disabled) {
+      return;
+    } // When a user hits ENTER, we'll clear the selection
+
+
+    if (match(event, Enter)) {
+      clearSelection(event);
+    }
+  };
+
+  var description = selectionCount ? t('clear.all') : t('clear.selection');
+  return React.createElement("div", {
+    role: "button",
+    className: className,
+    tabIndex: disabled ? -1 : 0,
+    onClick: handleOnClick,
+    onKeyDown: handleOnKeyDown,
+    "aria-label": "Clear Selection",
+    title: description
+  }, selectionCount, React.createElement(Close16, null));
+};
+
+var translationIds = {
+  'clear.all': 'clear.all',
+  'clear.selection': 'clear.selection'
+};
+var defaultTranslations = (_defaultTranslations = {}, _defineProperty(_defaultTranslations, translationIds['clear.all'], 'Clear all selected items'), _defineProperty(_defaultTranslations, translationIds['clear.selection'], 'Clear selected item'), _defaultTranslations);
+ListBoxSelection.propTypes = {
+  /**
+   * Specify a function to be invoked when a user interacts with the clear
+   * selection element.
+   */
+  clearSelection: PropTypes.func.isRequired,
+
+  /**
+   * Specify an optional `selectionCount` value that will be used to determine
+   * whether the selection should display a badge or a single clear icon.
+   */
+  selectionCount: PropTypes.number,
+
+  /**
+   * i18n hook used to provide the appropriate description for the given menu
+   * icon. This function takes in an id defined in `translationIds` and should
+   * return a string message for that given message id.
+   */
+  translateWithId: PropTypes.func.isRequired
+};
+ListBoxSelection.defaultProps = {
+  translateWithId: function translateWithId(id) {
+    return defaultTranslations[id];
+  }
+};
+
+export default ListBoxSelection;
+export { translationIds };

package/es/node_modules/carbon-components-react/es/components/ListBox/index.js

@@ -0,0 +1,21 @@
+import './ListBoxPropTypes.js';
+import ListBox from './ListBox.js';
+import ListBoxField from './ListBoxField.js';
+import ListBoxMenuItem from './ListBoxMenuItem.js';
+import ListBoxMenu from './ListBoxMenu.js';
+import ListBoxMenuIcon from './ListBoxMenuIcon.js';
+import ListBoxSelection from './ListBoxSelection.js';
+
+/**
+ * Copyright IBM Corp. 2016, 2018
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ListBox.Field = ListBoxField;
+ListBox.Menu = ListBoxMenu;
+ListBox.MenuIcon = ListBoxMenuIcon;
+ListBox.MenuItem = ListBoxMenuItem;
+ListBox.Selection = ListBoxSelection;
+
+export default ListBox;

package/es/node_modules/carbon-components-react/es/prop-types/childrenOfType.js

@@ -0,0 +1,36 @@
+import { Children } from 'react';
+import createChainableTypeChecker from './tools/createChainableTypeChecker.js';
+import getDisplayName from './tools/getDisplayName.js';
+
+/**
+ * Copyright IBM Corp. 2016, 2018
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * `childrenOfType` is used for asserting that children of a given React
+ * component are only of a given type. Currently, this supports React elements,
+ * Stateless Functional Components, and Class-based components.
+ *
+ * This prop validator also supports chaining through `isRequired`
+ */
+
+var childrenOfType = function childrenOfType(expectedChildType) {
+  var expectedDisplayName = getDisplayName( // Support both React elements and components by using `type` if it exists
+  expectedChildType.type || expectedChildType);
+
+  var validate = function validate(props, propName, componentName) {
+    Children.forEach(props[propName], function (child) {
+      var childDisplayName = getDisplayName(child.type);
+
+      if (child.type !== expectedChildType.type && child.type !== expectedChildType) {
+        throw new Error("Invalid prop `children` of type `".concat(childDisplayName, "` ") + "supplied to `".concat(componentName, "`, expected each child to be a ") + "`".concat(expectedDisplayName, "` component."));
+      }
+    });
+  };
+
+  return createChainableTypeChecker(validate);
+};
+
+export default childrenOfType;

package/es/node_modules/carbon-components-react/es/prop-types/tools/createChainableTypeChecker.js

@@ -0,0 +1,38 @@
+/**
+ * Copyright IBM Corp. 2016, 2018
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * `createChainableTypeChecker` is used inside of our custom prop validators to
+ * add in chaining `isRequired` on a given prop validator.
+ */
+var createChainableTypeChecker = function createChainableTypeChecker(validate) {
+  // `checkType` is borrowed heavily from the `prop-types` package
+  var checkType = function checkType(isRequired, props, propName, componentName, location) {
+    if (props[propName] == null) {
+      if (isRequired) {
+        if (props[propName] === null) {
+          return new Error("The ".concat(location, " `").concat(propName, "` is marked as required in ") + "".concat(componentName, ", but its value is `null`."));
+        }
+
+        return new Error("The ".concat(location, " `").concat(propName, "` is marked as required in ") + "".concat(componentName, ", but its value is `undefined`."));
+      }
+
+      return null;
+    } else {
+      return validate(props, propName, componentName, location);
+    }
+  }; // By default, the validator will have `isRequired` set to false. However, we
+  // also define the `isRequired` property on the validtor so that consumers can
+  // chain their prop validator and assert that the property is required.
+
+
+  var chainedCheckType = checkType.bind(null, false);
+  chainedCheckType.isRequired = checkType.bind(null, true);
+  return chainedCheckType;
+};
+
+export default createChainableTypeChecker;

package/es/node_modules/carbon-components-react/es/prop-types/tools/getDisplayName.js

@@ -0,0 +1,37 @@
+/**
+ * Copyright IBM Corp. 2016, 2018
+ *
+ * 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 cachedDisplayNames = new WeakMap();
+/**
+ * `getDisplayName` is a utility function for getting a name from a given
+ * component type. It supports names from React elements, Stateless Functional
+ * Components, and Class-based Components
+ */
+
+var getDisplayName = function getDisplayName(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  if (cachedDisplayNames.has(type)) {
+    return cachedDisplayNames.get(type);
+  }
+
+  var displayName;
+
+  if (typeof type.displayName === 'string') {
+    displayName = type.displayName;
+  }
+
+  if (!displayName) {
+    displayName = type.name || 'Unknown';
+  }
+
+  cachedDisplayNames.set(type, displayName);
+  return displayName;
+};
+
+export default getDisplayName;