0.2.0 - Mid migration

web/node_modules/@material-ui/core/test-utils/RenderMode.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RenderContext = RenderContext;
+exports.useIsSsr = useIsSsr;
+
+var React = _interopRequireWildcard(require("react"));
+
+var PropTypes = _interopRequireWildcard(require("prop-types"));
+
+var Context = React.createContext();
+
+if (process.env.NODE_ENV !== 'production') {
+  Context.displayName = 'RenderContext';
+}
+/**
+ * @ignore - internal component.
+ */
+
+
+function RenderContext(_ref) {
+  var children = _ref.children;
+  return /*#__PURE__*/React.createElement(Context.Provider, {
+    value: "render"
+  }, children);
+}
+
+process.env.NODE_ENV !== "production" ? RenderContext.propTypes = {
+  children: PropTypes.node.isRequired
+} : void 0;
+
+function useIsSsr() {
+  return React.useContext(Context) === 'render';
+}

web/node_modules/@material-ui/core/test-utils/createMount.d.ts

@@ -0,0 +1,17 @@
+import { mount } from 'enzyme';
+
+export interface MountOptions {
+  mount: typeof mount;
+  strict: boolean;
+}
+
+/**
+ * @deprecated
+ * @param options
+ */
+export default function createMount(
+  options?: Partial<MountOptions>
+): typeof mount & {
+  attachTo: HTMLElement;
+  cleanUp(): void;
+};

web/node_modules/@material-ui/core/test-utils/createMount.js

@@ -0,0 +1,129 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createMount;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var ReactDOM = _interopRequireWildcard(require("react-dom"));
+
+var PropTypes = _interopRequireWildcard(require("prop-types"));
+
+var _enzyme = require("enzyme");
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+/**
+ * Can't just mount <React.Fragment>{node}</React.Fragment>
+ * because that swallows wrapper.setProps
+ *
+ * why class component:
+ * https://github.com/airbnb/enzyme/issues/2043
+ */
+// eslint-disable-next-line react/prefer-stateless-function
+var Mode = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2.default)(Mode, _React$Component);
+
+  var _super = _createSuper(Mode);
+
+  function Mode() {
+    (0, _classCallCheck2.default)(this, Mode);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(Mode, [{
+    key: "render",
+    value: function render() {
+      // Excess props will come from e.g. enzyme setProps
+      var _this$props = this.props,
+          __element = _this$props.__element,
+          __strict = _this$props.__strict,
+          other = (0, _objectWithoutProperties2.default)(_this$props, ["__element", "__strict"]);
+      var Component = __strict ? React.StrictMode : React.Fragment;
+      return /*#__PURE__*/React.createElement(Component, null, /*#__PURE__*/React.cloneElement(__element, other));
+    }
+  }]);
+  return Mode;
+}(React.Component);
+
+process.env.NODE_ENV !== "production" ? Mode.propTypes = {
+  /**
+   * this is essentially children. However we can't use children because then
+   * using `wrapper.setProps({ children })` would work differently if this component
+   * would be the root.
+   */
+  __element: PropTypes.element.isRequired,
+  __strict: PropTypes.bool.isRequired
+} : void 0;
+var warnedOnce = false; // Generate an enhanced mount function.
+
+function createMount() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  if (!warnedOnce) {
+    warnedOnce = true;
+    console.warn(['Material-UI: the test utils are deprecated, they are no longer present in v5.', 'The helpers were designed to work with enzyme.', 'However, the tests of the core components were moved to react-testing-library.'].join('\n'));
+  }
+
+  var _options$mount = options.mount,
+      mount = _options$mount === void 0 ? _enzyme.mount : _options$mount,
+      globalStrict = options.strict,
+      globalEnzymeOptions = (0, _objectWithoutProperties2.default)(options, ["mount", "strict"]);
+  var attachTo = document.createElement('div');
+  attachTo.className = 'app';
+  attachTo.setAttribute('id', 'app');
+  document.body.insertBefore(attachTo, document.body.firstChild);
+
+  var mountWithContext = function mountWithContext(node) {
+    var localOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var _localOptions$disable = localOptions.disableUnnmount,
+        disableUnnmount = _localOptions$disable === void 0 ? false : _localOptions$disable,
+        _localOptions$strict = localOptions.strict,
+        strict = _localOptions$strict === void 0 ? globalStrict : _localOptions$strict,
+        localEnzymeOptions = (0, _objectWithoutProperties2.default)(localOptions, ["disableUnnmount", "strict"]);
+
+    if (!disableUnnmount) {
+      ReactDOM.unmountComponentAtNode(attachTo);
+    } // some tests require that no other components are in the tree
+    // e.g. when doing .instance(), .state() etc.
+
+
+    return mount(strict == null ? node : /*#__PURE__*/React.createElement(Mode, {
+      __element: node,
+      __strict: Boolean(strict)
+    }), (0, _extends2.default)({
+      attachTo: attachTo
+    }, globalEnzymeOptions, localEnzymeOptions));
+  };
+
+  mountWithContext.attachTo = attachTo;
+
+  mountWithContext.cleanUp = function () {
+    ReactDOM.unmountComponentAtNode(attachTo);
+    attachTo.parentElement.removeChild(attachTo);
+  };
+
+  return mountWithContext;
+}

web/node_modules/@material-ui/core/test-utils/createRender.d.ts

@@ -0,0 +1,11 @@
+import { render } from 'enzyme';
+
+export interface RenderOptions {
+  render: typeof render;
+}
+
+/**
+ * @deprecated
+ * @param options
+ */
+export default function createRender(options?: Partial<RenderOptions>): typeof render;

web/node_modules/@material-ui/core/test-utils/createRender.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createRender;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _enzyme = require("enzyme");
+
+var React = _interopRequireWildcard(require("react"));
+
+var _RenderMode = require("./RenderMode");
+
+var warnedOnce = false;
+/**
+ * Generate a render to string function.
+ * @deprecated to remvoe in v5
+ */
+
+function createRender() {
+  var options1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  if (!warnedOnce) {
+    warnedOnce = true;
+    console.warn(['Material-UI: the test utils are deprecated, they are no longer present in v5.', 'The helpers were designed to work with enzyme.', 'However, the tests of the core components were moved to react-testing-library.'].join('\n'));
+  }
+
+  var _options1$render = options1.render,
+      render = _options1$render === void 0 ? _enzyme.render : _options1$render,
+      other1 = (0, _objectWithoutProperties2.default)(options1, ["render"]);
+
+  var renderWithContext = function renderWithContext(node) {
+    var options2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return render( /*#__PURE__*/React.createElement(_RenderMode.RenderContext, null, node), (0, _extends2.default)({}, other1, options2));
+  };
+
+  return renderWithContext;
+}

web/node_modules/@material-ui/core/test-utils/createShallow.d.ts

@@ -0,0 +1,13 @@
+import { shallow, EnzymeSelector, ShallowRendererProps } from 'enzyme';
+
+export interface ShallowOptions extends ShallowRendererProps {
+  shallow: typeof shallow;
+  dive: boolean;
+  untilSelector: EnzymeSelector;
+}
+
+/**
+ * @deprecated
+ * @param options
+ */
+export default function createShallow(options?: Partial<ShallowOptions>): typeof shallow;

web/node_modules/@material-ui/core/test-utils/createShallow.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createShallow;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _enzyme = require("enzyme");
+
+var _until = _interopRequireDefault(require("./until"));
+
+var warnedOnce = false; // Generate an enhanced shallow function.
+
+function createShallow() {
+  var options1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  if (!warnedOnce) {
+    warnedOnce = true;
+    console.warn(['Material-UI: the test utils are deprecated, they are no longer present in v5.', 'The helpers were designed to work with enzyme.', 'However, the tests of the core components were moved to react-testing-library.'].join('\n'));
+  }
+
+  var _options1$shallow = options1.shallow,
+      shallow = _options1$shallow === void 0 ? _enzyme.shallow : _options1$shallow,
+      _options1$dive = options1.dive,
+      dive = _options1$dive === void 0 ? false : _options1$dive,
+      _options1$untilSelect = options1.untilSelector,
+      untilSelector = _options1$untilSelect === void 0 ? false : _options1$untilSelect,
+      other1 = (0, _objectWithoutProperties2.default)(options1, ["shallow", "dive", "untilSelector"]);
+
+  var shallowWithContext = function shallowWithContext(node) {
+    var options2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var options = (0, _extends2.default)({}, other1, options2, {
+      context: (0, _extends2.default)({}, other1.context, options2.context)
+    });
+    var wrapper = shallow(node, options);
+
+    if (dive) {
+      return wrapper.dive();
+    }
+
+    if (untilSelector) {
+      return _until.default.call(wrapper, untilSelector, options);
+    }
+
+    return wrapper;
+  };
+
+  return shallowWithContext;
+}

web/node_modules/@material-ui/core/test-utils/describeConformance.js

@@ -0,0 +1,255 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = describeConformance;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _chai = require("chai");
+
+var React = _interopRequireWildcard(require("react"));
+
+var _findOutermostIntrinsic = _interopRequireDefault(require("./findOutermostIntrinsic"));
+
+var _reactTestRenderer = _interopRequireDefault(require("react-test-renderer"));
+
+var _testRef = _interopRequireDefault(require("./testRef"));
+
+/**
+ * Glossary
+ * - root component:
+ *   - renders the outermost host component
+ *   - has the `root` class if the component has one
+ *   - excess props are spread to this component
+ *   - has the type of `inheritComponent`
+ */
+
+/**
+ * Returns the component with the same constructor as `component` that renders
+ * the outermost host
+ *
+ * @param {import('enzyme').ReactWrapper} wrapper
+ * @param {object} options
+ * @param {import('react').ElementType} component
+ */
+function findRootComponent(wrapper, _ref) {
+  var component = _ref.component;
+  var outermostHostElement = (0, _findOutermostIntrinsic.default)(wrapper).getElement();
+  return wrapper.find(component).filterWhere(function (componentWrapper) {
+    return componentWrapper.contains(outermostHostElement);
+  });
+}
+
+function randomStringValue() {
+  return Math.random().toString(36).slice(2);
+}
+/**
+ * Material-UI components have a `className` prop. The `className` is applied to
+ * the root component.
+ *
+ * @param {React.ReactElement} element
+ * @param {() => ConformanceOptions} getOptions
+ */
+
+
+function testClassName(element, getOptions) {
+  it('applies the className to the root component', function () {
+    var _getOptions = getOptions(),
+        mount = _getOptions.mount;
+
+    var className = randomStringValue();
+    var wrapper = mount( /*#__PURE__*/React.cloneElement(element, {
+      className: className
+    }));
+    (0, _chai.expect)((0, _findOutermostIntrinsic.default)(wrapper).hasClass(className)).to.equal(true, 'does have a custom `className`');
+  });
+}
+/**
+ * Material-UI components have a `component` prop that allows rendering a different
+ * Component from @inheritComponent
+ *
+ * @param {React.ReactElement} element
+ * @param {() => ConformanceOptions} getOptions
+ */
+
+
+function testComponentProp(element, getOptions) {
+  describe('prop: component', function () {
+    it('can render another root component with the `component` prop', function () {
+      var _getOptions2 = getOptions(),
+          classes = _getOptions2.classes,
+          mount = _getOptions2.mount,
+          _getOptions2$testComp = _getOptions2.testComponentPropWith,
+          component = _getOptions2$testComp === void 0 ? 'em' : _getOptions2$testComp;
+
+      var wrapper = mount( /*#__PURE__*/React.cloneElement(element, {
+        component: component
+      }));
+      (0, _chai.expect)(findRootComponent(wrapper, {
+        classes: classes,
+        component: component
+      }).exists()).to.equal(true);
+    });
+  });
+}
+/**
+ * Material-UI components can spread additional props to a documented component.
+ * It's set via @inheritComponent in the source.
+ *
+ * @param {React.ReactElement} element
+ * @param {() => ConformanceOptions} getOptions
+ */
+
+
+function testPropsSpread(element, getOptions) {
+  it("spreads props to the root component", function () {
+    // type def in ConformanceOptions
+    var _getOptions3 = getOptions(),
+        classes = _getOptions3.classes,
+        inheritComponent = _getOptions3.inheritComponent,
+        mount = _getOptions3.mount;
+
+    var testProp = 'data-test-props-spread';
+    var value = randomStringValue();
+    var wrapper = mount( /*#__PURE__*/React.cloneElement(element, (0, _defineProperty2.default)({}, testProp, value)));
+    var root = findRootComponent(wrapper, {
+      classes: classes,
+      component: inheritComponent
+    });
+    (0, _chai.expect)(root.props()[testProp]).to.equal(value);
+  });
+}
+/**
+ * Tests that the `ref` of a component will return the correct instance
+ *
+ * This is determined by a given constructor i.e. a React.Component or HTMLElement for
+ * components that forward their ref and attach it to a host component.
+ *
+ * @param {React.ReactElement} element
+ * @param {() => ConformanceOptions} getOptions
+ */
+
+
+function describeRef(element, getOptions) {
+  describe('ref', function () {
+    it("attaches the ref", function () {
+      // type def in ConformanceOptions
+      var _getOptions4 = getOptions(),
+          inheritComponent = _getOptions4.inheritComponent,
+          mount = _getOptions4.mount,
+          refInstanceof = _getOptions4.refInstanceof;
+
+      (0, _testRef.default)(element, mount, function (instance, wrapper) {
+        (0, _chai.expect)(instance).to.be.instanceof(refInstanceof);
+
+        if (inheritComponent && instance.nodeType === 1) {
+          var rootHost = (0, _findOutermostIntrinsic.default)(wrapper);
+          (0, _chai.expect)(instance).to.equal(rootHost.instance());
+        }
+      });
+    });
+  });
+}
+/**
+ * Tests that the root component has the root class
+ *
+ * @param {React.ReactElement} element
+ * @param {() => ConformanceOptions} getOptions
+ */
+
+
+function testRootClass(element, getOptions) {
+  it('applies the root class to the root component if it has this class', function () {
+    var _getOptions5 = getOptions(),
+        classes = _getOptions5.classes,
+        mount = _getOptions5.mount;
+
+    if (classes.root == null) {
+      return;
+    }
+
+    var className = randomStringValue();
+    var wrapper = mount( /*#__PURE__*/React.cloneElement(element, {
+      className: className
+    })); // we established that the root component renders the outermost host previously. We immediately
+    // jump to the host component because some components pass the `root` class
+    // to the `classes` prop of the root component.
+    // https://github.com/mui-org/material-ui/blob/f9896bcd129a1209153106296b3d2487547ba205/packages/material-ui/src/OutlinedInput/OutlinedInput.js#L101
+
+    (0, _chai.expect)((0, _findOutermostIntrinsic.default)(wrapper).hasClass(classes.root)).to.equal(true);
+    (0, _chai.expect)((0, _findOutermostIntrinsic.default)(wrapper).hasClass(className)).to.equal(true);
+  });
+}
+/**
+ * Tests that the component can be rendered with react-test-renderer.
+ * This is important for snapshot testing with Jest (even if we don't encourage it).
+ *
+ * @param {React.ReactElement} element
+ */
+
+
+function testReactTestRenderer(element) {
+  it('should render without errors in ReactTestRenderer', function () {
+    _reactTestRenderer.default.act(function () {
+      _reactTestRenderer.default.create(element, {
+        createNodeMock: function createNodeMock(node) {
+          return document.createElement(node.type);
+        }
+      });
+    });
+  });
+}
+
+var fullSuite = {
+  componentProp: testComponentProp,
+  mergeClassName: testClassName,
+  propsSpread: testPropsSpread,
+  refForwarding: describeRef,
+  rootClass: testRootClass,
+  reactTestRenderer: testReactTestRenderer
+};
+/**
+ * @typedef {Object} ConformanceOptions
+ * @property {Record<string, string>} classes - `classes` of the component provided by `@material-ui/styles`
+ * @property {string} inheritComponent - The element type that receives spread props.
+ * @property {function} mount - Should be a return value from createMount
+ * @property {(keyof typeof fullSuite)[]} [only] - If specified only run the tests listed
+ * @property {any} refInstanceof - `ref` will be an instanceof this constructor.
+ * @property {keyof typeof fullSuite[]} [skip] - Skip the specified tests
+ * @property {string} [testComponentPropWith] - The host component that should be rendered instead.
+ */
+
+/**
+ * Tests various aspects of a component that should be equal across Material-UI
+ * components.
+ *
+ * @param {React.ReactElement} minimalElement - the component with it's minimal required props
+ * @param {() => ConformanceOptions} getOptions
+ *
+ */
+
+function describeConformance(minimalElement, getOptions) {
+  var _getOptions6 = getOptions(),
+      _getOptions6$after = _getOptions6.after,
+      runAfterHook = _getOptions6$after === void 0 ? function () {} : _getOptions6$after,
+      _getOptions6$only = _getOptions6.only,
+      only = _getOptions6$only === void 0 ? Object.keys(fullSuite) : _getOptions6$only,
+      _getOptions6$skip = _getOptions6.skip,
+      skip = _getOptions6$skip === void 0 ? [] : _getOptions6$skip;
+
+  describe('Material-UI component API', function () {
+    after(runAfterHook);
+    Object.keys(fullSuite).filter(function (testKey) {
+      return only.indexOf(testKey) !== -1 && skip.indexOf(testKey) === -1;
+    }).forEach(function (testKey) {
+      var test = fullSuite[testKey];
+      test(minimalElement, getOptions);
+    });
+  });
+}

web/node_modules/@material-ui/core/test-utils/findOutermostIntrinsic.d.ts

@@ -0,0 +1,9 @@
+import { ReactWrapper } from 'enzyme';
+
+/**
+ * @deprecated
+ * like ReactWrapper#getDOMNode() but returns a ReactWrapper
+ *
+ * @returns the wrapper for the outermost DOM node
+ */
+export default function findOutermostIntrinsic(reactWrapper: ReactWrapper): ReactWrapper;

web/node_modules/@material-ui/core/test-utils/findOutermostIntrinsic.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrapsIntrinsicElement = wrapsIntrinsicElement;
+exports.default = findOutermostIntrinsic;
+
+/**
+ * checks if a given react wrapper wraps an intrinsic element i.e. a DOM node
+ *
+ * @param {import('enzyme').ReactWrapper} reactWrapper
+ * @returns {boolean} true if the given reactWrapper wraps an intrinsic element
+ */
+function wrapsIntrinsicElement(reactWrapper) {
+  return typeof reactWrapper.type() === 'string';
+}
+
+var warnedOnce = false;
+/**
+ * like ReactWrapper#getDOMNode() but returns a ReactWrapper
+ *
+ * @param {import('enzyme').ReactWrapper} reactWrapper
+ * @returns {import('enzyme').ReactWrapper} the wrapper for the outermost DOM node
+ */
+
+function findOutermostIntrinsic(reactWrapper) {
+  if (!warnedOnce) {
+    warnedOnce = true;
+    console.warn(['Material-UI: the test utils are deprecated, they are no longer present in v5.', 'The helpers were designed to work with enzyme.', 'However, the tests of the core components were moved to react-testing-library.'].join('\n'));
+  }
+
+  return reactWrapper.findWhere(function (n) {
+    return n.exists() && wrapsIntrinsicElement(n);
+  }).first();
+}

web/node_modules/@material-ui/core/test-utils/getClasses.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @deprecated
+ * @param element
+ * @param options
+ */
+export default function getClasses<T = { [name: string]: string }>(
+  element: React.ReactElement,
+  options?: Partial<{ withTheme: boolean }>
+): T;

web/node_modules/@material-ui/core/test-utils/getClasses.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getClasses;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _createShallow = _interopRequireDefault(require("./createShallow"));
+
+var shallow = (0, _createShallow.default)();
+var warnedOnce = false; // Helper function to extract the classes from a styleSheet.
+
+function getClasses(element) {
+  if (!warnedOnce) {
+    warnedOnce = true;
+    console.warn(['Material-UI: the test utils are deprecated, they are no longer present in v5.', 'The helpers were designed to work with enzyme.', 'However, the tests of the core components were moved to react-testing-library.'].join('\n'));
+  }
+
+  var useStyles = element.type.useStyles;
+  var classes;
+
+  function Listener() {
+    classes = useStyles(element.props);
+    return null;
+  }
+
+  shallow( /*#__PURE__*/React.createElement(Listener, null));
+  return classes;
+}

web/node_modules/@material-ui/core/test-utils/index.d.ts

@@ -0,0 +1,6 @@
+export { default as createShallow } from './createShallow';
+export { default as createMount } from './createMount';
+export { default as createRender } from './createRender';
+export { default as findOutermostIntrinsic } from './findOutermostIntrinsic';
+export { default as getClasses } from './getClasses';
+export { default as unwrap } from './unwrap';

web/node_modules/@material-ui/core/test-utils/index.js

@@ -0,0 +1,63 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createShallow", {
+  enumerable: true,
+  get: function get() {
+    return _createShallow.default;
+  }
+});
+Object.defineProperty(exports, "createMount", {
+  enumerable: true,
+  get: function get() {
+    return _createMount.default;
+  }
+});
+Object.defineProperty(exports, "createRender", {
+  enumerable: true,
+  get: function get() {
+    return _createRender.default;
+  }
+});
+Object.defineProperty(exports, "findOutermostIntrinsic", {
+  enumerable: true,
+  get: function get() {
+    return _findOutermostIntrinsic.default;
+  }
+});
+Object.defineProperty(exports, "wrapsIntrinsicElement", {
+  enumerable: true,
+  get: function get() {
+    return _findOutermostIntrinsic.wrapsIntrinsicElement;
+  }
+});
+Object.defineProperty(exports, "getClasses", {
+  enumerable: true,
+  get: function get() {
+    return _getClasses.default;
+  }
+});
+Object.defineProperty(exports, "unwrap", {
+  enumerable: true,
+  get: function get() {
+    return _unwrap.default;
+  }
+});
+
+var _createShallow = _interopRequireDefault(require("./createShallow"));
+
+var _createMount = _interopRequireDefault(require("./createMount"));
+
+var _createRender = _interopRequireDefault(require("./createRender"));
+
+var _findOutermostIntrinsic = _interopRequireWildcard(require("./findOutermostIntrinsic"));
+
+var _getClasses = _interopRequireDefault(require("./getClasses"));
+
+var _unwrap = _interopRequireDefault(require("./unwrap"));

web/node_modules/@material-ui/core/test-utils/package.json

@@ -0,0 +1,5 @@
+{
+  "sideEffects": false,
+  "module": "../esm/test-utils/index.js",
+  "typings": "./index.d.ts"
+}

web/node_modules/@material-ui/core/test-utils/testRef.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = testRef;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _chai = require("chai");
+
+function assertDOMNode(node) {
+  // duck typing a DOM node
+  (0, _chai.expect)((0, _typeof2.default)(node.nodeName)).to.equal('string');
+}
+/**
+ * Utility method to make assertions about the ref on an element
+ * @param {React.ReactElement} element - The element should have a component wrapped
+ *                                       in withStyles as the root
+ * @param {function} mount - Should be returnvalue of createMount
+ * @param {function} onRef - Callback, first arg is the ref.
+ *                           Assert that the ref is a DOM node by default
+ */
+
+
+function testRef(element, mount) {
+  var onRef = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : assertDOMNode;
+  var ref = /*#__PURE__*/React.createRef();
+  var wrapper = mount( /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.cloneElement(element, {
+    ref: ref
+  })));
+  onRef(ref.current, wrapper);
+}

web/node_modules/@material-ui/core/test-utils/until.d.ts

@@ -0,0 +1,11 @@
+import { CommonWrapper } from 'enzyme';
+
+/**
+ * @deprecated
+ * @param selector
+ * @param options
+ */
+export default function until<P = any, S = any>(
+  selector: string,
+  options: { context: any }
+): CommonWrapper<P, S>;

web/node_modules/@material-ui/core/test-utils/until.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = until;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+function shallowRecursively(wrapper, selector, _ref) {
+  var context = _ref.context,
+      other = (0, _objectWithoutProperties2.default)(_ref, ["context"]);
+
+  if (wrapper.isEmptyRender() || typeof wrapper.getElement().type === 'string') {
+    return wrapper;
+  }
+
+  var newContext = context;
+  var instance = wrapper.root().instance(); // The instance can be null with a stateless functional component and react >= 16.
+
+  if (instance && instance.getChildContext) {
+    newContext = (0, _extends2.default)({}, context, instance.getChildContext());
+  }
+
+  var nextWrapper = wrapper.shallow((0, _extends2.default)({
+    context: newContext
+  }, other));
+
+  if (selector && wrapper.is(selector)) {
+    return nextWrapper;
+  }
+
+  return shallowRecursively(nextWrapper, selector, {
+    context: newContext
+  });
+}
+
+var warnedOnce = false;
+
+function until(selector) {
+  var _this = this;
+
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  if (!warnedOnce) {
+    warnedOnce = true;
+    console.warn(['Material-UI: the test utils are deprecated, they are no longer present in v5.', 'The helpers were designed to work with enzyme.', 'However, the tests of the core components were moved to react-testing-library.'].join('\n'));
+  }
+
+  return this.single('until', function () {
+    return shallowRecursively(_this, selector, options);
+  });
+}

web/node_modules/@material-ui/core/test-utils/unwrap.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @deprecated
+ * @param element
+ */
+export default function unwrap(element: React.ReactElement): React.ReactElement;

web/node_modules/@material-ui/core/test-utils/unwrap.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = unwrap;
+var warnedOnce = false;
+
+function unwrap(component) {
+  if (!warnedOnce) {
+    warnedOnce = true;
+    console.warn(['Material-UI: the test utils are deprecated, they are no longer present in v5.', 'The helpers were designed to work with enzyme.', 'However, the tests of the core components were moved to react-testing-library.'].join('\n'));
+  }
+
+  return component.Naked;
+}