@mui/internal-test-utils 2.0.15 → 2.0.18-canary.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
-# Changelog
+# Versions
 
-## 1.0.0
+## 2.0.8
 
-Initial release as an npm package.
+Test release
+
+## 2.0.7
+
+Test release
+
+## 2.0.6
+
+Changelog start

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014 Call-Em-All
+Copyright (c) 2019 Material-UI SAS
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,9 +1,55 @@
-# @mui/internal-test-utils
+# MUI Public
 
-This package contains test runner initialization functions and common tests shared between MUI packages.
-This is an internal package not meant for general use.
+Mono-repository for the MUI organization with code that can be public.
+See https://github.com/mui/mui-private for code that needs to be private.
 
-## Release
+## Documentation
 
-1. Build the project: `pnpm build`
-2. Publish the build artifacts to npm: `pnpm release:publish`
+You can [read the Infra documentation here](./docs/README.md).
+
+## Applications
+
+### [tools-public.mui.com](https://tools-public.mui.com/)
+
+- Folder: `/apps/tools-public/`
+- Hosting: https://dashboard.render.com/web/srv-d08mooq4d50c73fso49g
+- [Docs](./apps/tools-public/#readme)
+
+Internal public Toolpad apps that run the operations of MUI, built using https://github.com/mui/toolpad.
+
+### [Code infra dashboard](https://frontend-public.mui.com/)
+
+- URL: [frontend-public.mui.com](https://frontend-public.mui.com/)
+- Folder: `/apps/code-infra-dashboard/`
+- Hosting: https://app.netlify.com/sites/mui-frontend-public/overview
+- [Docs](./apps/code-infra-dashboard/#readme)
+
+## Packages
+
+### [docs-infra](./packages/docs-infra/)
+
+- Folder: `/packages/docs-infra/`
+- [Docs](./packages/docs-infra/README.md)
+
+### [code-infra](./packages/code-infra/)
+
+- Folder: `/packages/code-infra/`
+- [Docs](./packages/code-infra/README.md)
+
+## Versioning
+
+Steps:
+
+1. Checkout latest master
+1. Run `pnpm release:prepare`
+1. Run `pnpm release:version`
+1. Open PR with the changes
+
+## Publishing
+
+Steps:
+
+1. Merge versioning PR
+1. Checkout release commit on master
+1. Run `pnpm release:prepare`
+1. Run `pnpm release:publish`

package/chaiPlugin.d.ts

@@ -0,0 +1,3 @@
+import * as chai from 'chai';
+declare const chaiPlugin: Parameters<typeof chai.use>[0];
+export default chaiPlugin;

package/chaiPlugin.js

@@ -0,0 +1,300 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dom = require("@testing-library/dom");
+var _pure = require("@testing-library/react/pure.js");
+var _domAccessibilityApi = require("dom-accessibility-api");
+var _formatUtil = _interopRequireDefault(require("format-util"));
+var _string = require("es-toolkit/string");
+var _assertionError = require("assertion-error");
+var _env = require("./env");
+// eslint-disable-next-line import/extensions
+
+// chai#utils.elToString that looks like stringified elements in testing-library
+function elementToString(element) {
+  if (typeof element?.nodeType === 'number') {
+    return (0, _pure.prettyDOM)(element, undefined, {
+      highlight: true,
+      maxDepth: 1
+    });
+  }
+  return String(element);
+}
+const chaiPlugin = (chaiAPI, utils) => {
+  const blockElements = new Set(['html', 'address', 'blockquote', 'body', 'dd', 'div', 'dl', 'dt', 'fieldset', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'noframes', 'ol', 'p', 'ul', 'center', 'dir', 'hr', 'menu', 'pre']);
+  function pretendVisibleGetComputedStyle(element) {
+    // `CSSStyleDeclaration` is not constructable
+    // https://stackoverflow.com/a/52732909/3406963
+    // this is not equivalent to the declaration from `getComputedStyle`
+    // for example `getComputedStyle` would return a readonly declaration
+    // let's hope this doesn't get passed around until it's no longer clear where it comes from
+    const declaration = document.createElement('span').style;
+
+    // initial values
+    declaration.content = '';
+    // technically it's `inline`. We partially apply the default user agent sheet (chrome) here
+    // we're only interested in elements that use block
+    declaration.display = blockElements.has(element.tagName) ? 'block' : 'inline';
+    declaration.visibility = 'visible';
+    return declaration;
+  }
+
+  // better diff view for expect(element).to.equal(document.activeElement)
+  chaiAPI.Assertion.addMethod('toHaveFocus', function elementIsFocused() {
+    const element = utils.flag(this, 'object');
+    this.assert(element === document.activeElement, `expected element to have focus`, `expected element to NOT have focus \n${elementToString(element)}`, elementToString(element), elementToString(document.activeElement));
+  });
+  chaiAPI.Assertion.addMethod('toHaveVirtualFocus', function elementIsVirtuallyFocused() {
+    const element = utils.flag(this, 'object');
+    const id = element.getAttribute('id');
+    const virtuallyFocusedElementId = document.activeElement.getAttribute('aria-activedescendant');
+    this.assert(virtuallyFocusedElementId === id, `expected element to be virtually focused\nexpected id #{exp}\n${virtuallyFocusedElementId === null ? `activeElement: ${elementToString(document.activeElement)}` : 'actual id: #{act}'}`, 'expected element to NOT to be virtually focused', id, virtuallyFocusedElementId, virtuallyFocusedElementId !== null);
+  });
+  chaiAPI.Assertion.addMethod('toBeInaccessible', function elementIsAccessible() {
+    const element = utils.flag(this, 'object');
+    const inaccessible = (0, _dom.isInaccessible)(element);
+    this.assert(inaccessible === true, `expected \n${elementToString(element)} to be inaccessible but it was accessible`, `expected \n${elementToString(element)} to be accessible but it was inaccessible`,
+    // Not interested in a diff but the typings require the 4th parameter.
+    undefined);
+  });
+  chaiAPI.Assertion.addMethod('toHaveAccessibleName', function hasAccessibleName(expectedName) {
+    const root = utils.flag(this, 'object');
+    // make sure it's an Element
+    new chaiAPI.Assertion(root.nodeType, `Expected an Element but got '${String(root)}'`).to.equal(1);
+    const actualName = (0, _domAccessibilityApi.computeAccessibleName)(root, {
+      computedStyleSupportsPseudoElements: !(0, _env.isJsdom)(),
+      // in local development we pretend to be visible. full getComputedStyle is
+      // expensive and reserved for CI
+      getComputedStyle: process.env.CI ? undefined : pretendVisibleGetComputedStyle
+    });
+    this.assert(actualName === expectedName, `expected \n${elementToString(root)} to have accessible name #{exp} but got #{act} instead.`, `expected \n${elementToString(root)} not to have accessible name #{exp}.`, expectedName, actualName);
+  });
+  chaiAPI.Assertion.addMethod('toHaveAccessibleDescription', function hasAccessibleDescription(expectedDescription) {
+    const root = utils.flag(this, 'object');
+    // make sure it's an Element
+    new chaiAPI.Assertion(root.nodeType, `Expected an Element but got '${String(root)}'`).to.equal(1);
+    const actualDescription = (0, _domAccessibilityApi.computeAccessibleDescription)(root, {
+      // in local development we pretend to be visible. full getComputedStyle is
+      // expensive and reserved for CI
+      getComputedStyle: process.env.CI ? undefined : pretendVisibleGetComputedStyle
+    });
+    const possibleDescriptionComputationMessage = root.hasAttribute('title') ? ' computeAccessibleDescription can be misleading when a `title` attribute is used. This might be a bug in `dom-accessibility-api`.' : '';
+    this.assert(actualDescription === expectedDescription, `expected \n${elementToString(root)} to have accessible description #{exp} but got #{act} instead.${possibleDescriptionComputationMessage}`, `expected \n${elementToString(root)} not to have accessible description #{exp}.${possibleDescriptionComputationMessage}`, expectedDescription, actualDescription);
+  });
+
+  /**
+   * Correct name for `to.be.visible`
+   */
+  chaiAPI.Assertion.addMethod('toBeVisible', function toBeVisible() {
+    // eslint-disable-next-line no-underscore-dangle, @typescript-eslint/no-unused-expressions
+    new chaiAPI.Assertion(this._obj).to.be.visible;
+  });
+
+  /**
+   * Correct name for `not.to.be.visible`
+   */
+  chaiAPI.Assertion.addMethod('toBeHidden', function toBeHidden() {
+    // eslint-disable-next-line no-underscore-dangle, @typescript-eslint/no-unused-expressions
+    new chaiAPI.Assertion(this._obj).not.to.be.visible;
+  });
+  function assertMatchingStyles(actualStyleDeclaration, expectedStyleUnnormalized, options) {
+    const {
+      styleTypeHint
+    } = options;
+
+    // Compare objects using hyphen case.
+    // This is closer to actual CSS and required for getPropertyValue anyway.
+    const expectedStyle = {};
+    Object.keys(expectedStyleUnnormalized).forEach(cssProperty => {
+      const hyphenCasedPropertyName = (0, _string.kebabCase)(cssProperty);
+      const isVendorPrefixed = /^(moz|ms|o|webkit)-/.test(hyphenCasedPropertyName);
+      const propertyName = isVendorPrefixed ? `-${hyphenCasedPropertyName}` : hyphenCasedPropertyName;
+      expectedStyle[propertyName] = expectedStyleUnnormalized[cssProperty];
+    });
+    const shorthandProperties = new Set(['all', 'animation', 'background', 'border', 'border-block-end', 'border-block-start', 'border-bottom', 'border-color', 'border-image', 'border-inline-end', 'border-inline-start', 'border-left', 'border-radius', 'border-right', 'border-style', 'border-top', 'border-width', 'column-rule', 'columns', 'flex', 'flex-flow', 'font', 'gap', 'grid', 'grid-area', 'grid-column', 'grid-row', 'grid-template', 'list-style', 'margin', 'mask', 'offset', 'outline', 'overflow', 'padding', 'place-content', 'place-items', 'place-self', 'scroll-margin', 'scroll-padding', 'text-decoration', 'text-emphasis', 'transition']);
+    const usedShorthandProperties = Object.keys(expectedStyle).filter(cssProperty => {
+      return shorthandProperties.has(cssProperty);
+    });
+    if (usedShorthandProperties.length > 0) {
+      throw new Error([`Shorthand properties are not supported in ${styleTypeHint} styles matchers since browsers can compute them differently. `, 'Use longhand properties instead for the follow shorthand properties:\n', usedShorthandProperties.map(cssProperty => {
+        return `- https://developer.mozilla.org/en-US/docs/Web/CSS/${cssProperty}#constituent_properties`;
+      }).join('\n')].join(''));
+    }
+    const actualStyle = {};
+    Object.keys(expectedStyle).forEach(cssProperty => {
+      actualStyle[cssProperty] = actualStyleDeclaration.getPropertyValue(cssProperty);
+    });
+    const jsdomHint = 'Styles in JSDOM e.g. from `test:unit` are often misleading since JSDOM does not implement the Cascade nor actual CSS property value computation. ' + "If results differ between real browsers and JSDOM, skip the test in JSDOM e.g. `it.skipIf(isJsdom())('...`";
+    const shorthandHint = 'Browsers can compute shorthand properties differently. Prefer longhand properties e.g. `borderTopColor`, `borderRightColor` etc. instead of `border` or `border-color`.';
+    const messageHint = `${jsdomHint}\n${shorthandHint}`;
+    this.assert(
+    // TODO Fix upstream docs/types
+    utils.eql(actualStyle, expectedStyle), `expected #{this} to have ${styleTypeHint} style #{exp} \n\n${messageHint}`, `expected #{this} not to have ${styleTypeHint} style #{exp}${messageHint}`, expectedStyle, actualStyle, true);
+  }
+  chaiAPI.Assertion.addMethod('toHaveInlineStyle', function toHaveInlineStyle(expectedStyleUnnormalized) {
+    const element = utils.flag(this, 'object');
+    if (element?.nodeType !== 1) {
+      // Same pre-condition for negated and unnegated assertion
+      throw new _assertionError.AssertionError(`Expected an Element but got ${String(element)}`);
+    }
+    assertMatchingStyles.call(this, element.style, expectedStyleUnnormalized, {
+      styleTypeHint: 'inline'
+    });
+  });
+  chaiAPI.Assertion.addMethod('toHaveComputedStyle', function toHaveComputedStyle(expectedStyleUnnormalized) {
+    const element = utils.flag(this, 'object');
+    if (element?.nodeType !== 1) {
+      // Same pre-condition for negated and unnegated assertion
+      throw new _assertionError.AssertionError(`Expected an Element but got ${String(element)}`);
+    }
+    const computedStyle = element.ownerDocument.defaultView.getComputedStyle(element);
+    assertMatchingStyles.call(this, computedStyle, expectedStyleUnnormalized, {
+      styleTypeHint: 'computed'
+    });
+  });
+  chaiAPI.Assertion.addMethod('toThrowMinified', function toThrowMinified(expectedDevMessage) {
+    // TODO: Investigate if `as any` can be removed after https://github.com/DefinitelyTyped/DefinitelyTyped/issues/48634 is resolved.
+    if (process.env.NODE_ENV !== 'production') {
+      this.to.throw(expectedDevMessage);
+    } else {
+      utils.flag(this, 'message', "Looks like the error was not minified. This can happen if the error code hasn't been generated yet. Run `pnpm extract-error-codes` and try again.");
+      // TODO: Investigate if `as any` can be removed after https://github.com/DefinitelyTyped/DefinitelyTyped/issues/48634 is resolved.
+      this.to.throw('Minified MUI error', 'helper');
+    }
+  });
+  function addConsoleMatcher(matcherName, methodName) {
+    function matcher(expectedMessagesInput = []) {
+      // documented pattern to get the actual value of the assertion
+      // eslint-disable-next-line no-underscore-dangle
+      const callback = this._obj;
+      if (process.env.NODE_ENV !== 'production') {
+        const expectedMessages = Array.isArray(expectedMessagesInput) ? expectedMessagesInput.slice() : [expectedMessagesInput];
+        const unexpectedMessages = [];
+        // TODO Remove type once MUI X enables noImplicitAny
+        let caughtError = null;
+        let result = null;
+        this.assert(expectedMessages.length > 0, `Expected to call console.${methodName} but didn't provide messages. ` + `If you don't expect any messages prefer \`expect().not.${matcherName}();\`.`, `Expected no call to console.${methodName} while also expecting messages. ` + "If you want to make sure a certain message isn't logged prefer the positive. " + 'By expecting certain messages you automatically expect that no other messages are logged',
+        // Not interested in a diff but the typings require the 4th parameter.
+        undefined);
+
+        // Ignore skipped messages in e.g. `[condition && 'foo']`
+        const remainingMessages = expectedMessages.filter(messageOrFalse => {
+          return messageOrFalse !== false;
+        });
+
+        // eslint-disable-next-line no-console
+        const originalMethod = console[methodName];
+        let messagesMatched = 0;
+        const consoleMatcher = (format, ...args) => {
+          // Ignore legacy root deprecation warnings
+          // TODO: Remove once we no longer use legacy roots.
+          if (format.includes('Use createRoot instead.') || format.includes('Use hydrateRoot instead.')) {
+            return;
+          }
+          const actualMessage = (0, _formatUtil.default)(format, ...args);
+          const expectedMessage = remainingMessages.shift();
+          messagesMatched += 1;
+
+          // TODO Remove type once MUI X enables noImplicitAny
+          let message = null;
+          if (expectedMessage === undefined) {
+            message = `Expected no more error messages but got:\n"${actualMessage}"`;
+          } else if (typeof expectedMessage === 'string' && !actualMessage.includes(expectedMessage) || expectedMessage instanceof RegExp && !expectedMessage.test(actualMessage)) {
+            message = `Expected #${messagesMatched} "${expectedMessage}" to be included in \n"${actualMessage}"`;
+          }
+          if (message !== null) {
+            const error = new Error(message);
+            const {
+              stack: fullStack
+            } = error;
+            const fullStacktrace = fullStack.replace(`Error: ${message}\n`, '').split('\n');
+            const usefulStacktrace = fullStacktrace
+            //
+            // first line points to this frame which is irrelevant for the tester
+            .slice(1);
+            const usefulStack = `${message}\n${usefulStacktrace.join('\n')}`;
+            error.stack = usefulStack;
+            unexpectedMessages.push(error);
+          }
+        };
+        // eslint-disable-next-line no-console
+        console[methodName] = consoleMatcher;
+        try {
+          result = callback();
+        } catch (error) {
+          caughtError = error;
+        } finally {
+          // unexpected thrown error takes precedence over unexpected console call
+          if (caughtError !== null) {
+            // not the same pattern as described in the block because we don't rethrow in the catch
+            // eslint-disable-next-line no-unsafe-finally
+            throw caughtError;
+          }
+          const formatMessages = messages => {
+            const formattedMessages = messages.map(message => {
+              if (typeof message === 'string') {
+                return `"${message}"`;
+              }
+              // full Error
+              return `${message.stack}`;
+            });
+            return `\n\n  - ${formattedMessages.join('\n\n-  ')}`;
+          };
+          const report = () => {
+            const shouldHaveWarned = utils.flag(this, 'negate') !== true;
+
+            // unreachable from expect().not.toWarnDev(messages)
+            if (unexpectedMessages.length > 0) {
+              const unexpectedMessageRecordedMessage = `Recorded unexpected console.${methodName} calls: ${formatMessages(unexpectedMessages)}`;
+              // chai will duplicate the stack frames from the unexpected calls in their assertion error
+              // it's not ideal but the test failure is located the second to last stack frame
+              // and the origin of the call is the second stackframe in the stack
+              this.assert(
+              // force chai to always trigger an assertion error
+              !shouldHaveWarned, unexpectedMessageRecordedMessage, unexpectedMessageRecordedMessage,
+              // Not interested in a diff but the typings require the 4th parameter.
+              undefined);
+            }
+            if (shouldHaveWarned) {
+              this.assert(remainingMessages.length === 0, `Could not match the following console.${methodName} calls. ` + `Make sure previous actions didn't call console.${methodName} by wrapping them in expect(() => {}).not.${matcherName}(): ${formatMessages(remainingMessages)}`, `Impossible state reached in \`expect().${matcherName}()\`. ` + `This is a bug in the matcher.`,
+              // Not interested in a diff but the typings require the 4th parameter.
+              undefined);
+            }
+          };
+          if (result && typeof result === 'object' && 'then' in result && typeof result.then === 'function') {
+            // Handle async callbacks
+            result = Promise.resolve(result).then(value => {
+              report();
+              return value;
+            }).finally(() => {
+              // eslint-disable-next-line no-console
+              console[methodName] = originalMethod;
+            });
+          } else {
+            // eslint-disable-next-line no-console
+            console[methodName] = originalMethod;
+            report();
+          }
+        }
+        return result;
+      }
+
+      // nothing to do in prod
+      // If there are still console calls than our test setup throws.
+      return callback();
+    }
+    chaiAPI.Assertion.addMethod(matcherName, matcher);
+  }
+
+  /**
+   * @example expect(() => render()).toWarnDev('single message')
+   * @example expect(() => render()).toWarnDev(['first warning', 'then the second'])
+   */
+  addConsoleMatcher('toWarnDev', 'warn');
+  addConsoleMatcher('toErrorDev', 'error');
+};
+var _default = exports.default = chaiPlugin;

package/{src/chai.types.ts → chaiTypes.d.ts}

@@ -1,64 +1,31 @@
 export {};
-
-// https://stackoverflow.com/a/46755166/3406963
 declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
   namespace Chai {
     interface Assertion {
       /**
        * Checks `expectedStyle` is a subset of the elements inline style i.e. `element.style`.
        * @example expect(element).toHaveInlineStyle({ width: '200px' })
        */
-      toHaveInlineStyle(
-        expectedStyle: Partial<
-          Record<
-            Exclude<
-              keyof CSSStyleDeclaration,
-              | 'getPropertyPriority'
-              | 'getPropertyValue'
-              | 'item'
-              | 'removeProperty'
-              | 'setProperty'
-              | number
-            >,
-            string
-          >
-        >,
-      ): void;
+      toHaveInlineStyle(expectedStyle: Partial<Record<Exclude<keyof CSSStyleDeclaration, 'getPropertyPriority' | 'getPropertyValue' | 'item' | 'removeProperty' | 'setProperty' | number>, string>>): void;
       /**
        * Checks `expectedStyle` is a subset of the elements computed style i.e. `window.getComputedStyle(element)`.
        * @example expect(element).toHaveComputedStyle({ width: '200px' })
        */
-      toHaveComputedStyle(
-        expectedStyle: Partial<
-          Record<
-            Exclude<
-              keyof CSSStyleDeclaration,
-              | 'getPropertyPriority'
-              | 'getPropertyValue'
-              | 'item'
-              | 'removeProperty'
-              | 'setProperty'
-              | number
-            >,
-            string
-          >
-        >,
-      ): void;
+      toHaveComputedStyle(expectedStyle: Partial<Record<Exclude<keyof CSSStyleDeclaration, 'getPropertyPriority' | 'getPropertyValue' | 'item' | 'removeProperty' | 'setProperty' | number>, string>>): void;
       /**
-       * Check if an element's [`visibility`](https://developer.mozilla.org/en-US/docs/Web/CSS/visibility) is not `hidden` or `collapsed`.
+       * Check if an element's [`visibility`](https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/visibility) is not `hidden` or `collapsed`.
        */
       toBeVisible(): void;
       /**
-       * Check if an element's [`visibility`](https://developer.mozilla.org/en-US/docs/Web/CSS/visibility) is `hidden` or `collapsed`.
+       * Check if an element's [`visibility`](https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/visibility) is `hidden` or `collapsed`.
        */
       toBeHidden(): void;
       /**
        * Checks if the element is inaccessible.
        *
        * Elements are considered inaccessible if they either:
-       * - have [`visibility`](https://developer.mozilla.org/en-US/docs/Web/CSS/visibility) `hidden`
-       * - have [`display`](https://developer.mozilla.org/en-US/docs/Web/CSS/display) `none`
+       * - have [`visibility`](https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/visibility) `hidden`
+       * - have [`display`](https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/display) `none`
        * - have `aria-hidden` `true` or any of their parents
        *
        * @see [Excluding Elements from the Accessibility Tree](https://www.w3.org/TR/wai-aria-1.2/#tree_exclusion)
@@ -104,4 +71,4 @@ declare global {
       toThrowMinified(message: string | RegExp): void;
     }
   }
-}
+}

package/chaiTypes.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/{build/components.d.ts → components.d.ts}

@@ -6,23 +6,23 @@ import PropTypes from 'prop-types';
  *          expect(errorRef.current.errors).to.have.length(0);
  */
 export declare class ErrorBoundary extends React.Component<{
-    children: React.ReactNode;
+  children: React.ReactNode;
 }> {
-    static propTypes: {
-        children: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
-    };
-    state: {
-        error: null;
-    };
-    /**
-     * @public
-     */
-    errors: unknown[];
-    static getDerivedStateFromError(error: unknown): {
-        error: unknown;
-    };
-    componentDidCatch(error: unknown): void;
-    render(): React.ReactNode;
+  static propTypes: {
+    children: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
+  };
+  state: {
+    error: null;
+  };
+  /**
+   * @public
+   */
+  errors: unknown[];
+  static getDerivedStateFromError(error: unknown): {
+    error: unknown;
+  };
+  componentDidCatch(error: unknown): void;
+  render(): React.ReactNode;
 }
 /**
  * Allows counting how many times the owner of `RenderCounter` rendered or
@@ -31,6 +31,5 @@ export declare class ErrorBoundary extends React.Component<{
  *          getRenderCountRef.current() === 2
  */
 export declare const RenderCounter: React.ForwardRefExoticComponent<{
-    children: React.ReactNode;
-} & React.RefAttributes<() => number>>;
-//# sourceMappingURL=components.d.ts.map
+  children: React.ReactNode;
+} & React.RefAttributes<() => number>>;

package/components.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RenderCounter = exports.ErrorBoundary = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _jsxRuntime = require("react/jsx-runtime");
+/**
+ * A basic error boundary that can be used to assert thrown errors in render.
+ * @example <ErrorBoundary ref={errorRef}><MyComponent /></ErrorBoundary>;
+ *          expect(errorRef.current.errors).to.have.length(0);
+ */
+class ErrorBoundary extends React.Component {
+  state = {
+    error: null
+  };
+
+  /**
+   * @public
+   */
+  errors = [];
+  static getDerivedStateFromError(error) {
+    return {
+      error
+    };
+  }
+  componentDidCatch(error) {
+    this.errors.push(error);
+  }
+  render() {
+    if (this.state.error) {
+      return null;
+    }
+    return this.props.children;
+  }
+}
+
+/**
+ * Allows counting how many times the owner of `RenderCounter` rendered or
+ * a component within the RenderCounter tree "commits" an update.
+ * @example <RenderCounter ref={getRenderCountRef}>...</RenderCounter>
+ *          getRenderCountRef.current() === 2
+ */
+exports.ErrorBoundary = ErrorBoundary;
+process.env.NODE_ENV !== "production" ? ErrorBoundary.propTypes = {
+  children: _propTypes.default.node.isRequired
+} : void 0;
+const RenderCounter = exports.RenderCounter = /*#__PURE__*/React.forwardRef(function RenderCounter({
+  children
+}, ref) {
+  const getRenderCountRef = React.useRef(0);
+  React.useImperativeHandle(ref, () => () => getRenderCountRef.current);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(React.Profiler, {
+    id: "render-counter",
+    onRender: () => {
+      getRenderCountRef.current += 1;
+    },
+    children: children
+  });
+});
+if (process.env.NODE_ENV !== "production") RenderCounter.displayName = "RenderCounter";

package/configure.d.ts

@@ -0,0 +1,9 @@
+export interface Configuration {
+  /**
+   * The emotion wrapper is optional.
+   * If your repository uses emotion, install `@emotion/react` and `@emotion/cache` and set this to true.
+   */
+  emotion: boolean;
+}
+export declare const config: Configuration;
+export declare function configure(newConfig?: Partial<Configuration>): void;

package/configure.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.config = void 0;
+exports.configure = configure;
+const defaultConfig = {
+  emotion: false
+};
+const config = exports.config = {
+  ...defaultConfig
+};
+function configure(newConfig = {}) {
+  Object.assign(config, newConfig);
+}

package/createDescribe.d.ts

@@ -0,0 +1,14 @@
+export type MUIDescribe<P extends any[]> = {
+  (...args: P): void;
+  skip: (...args: P) => void;
+  only: (...args: P) => void;
+};
+/**
+ * Create a custom describe function with chainable skip and only methods.
+ * It is used to group conformance tests but still make the focusable/skippable.
+ *
+ * @param message - The message to display for the describe block.
+ * @param callback - The callback function containing the tests.
+ * @returns A custom describe function with skip and only methods.
+ */
+export default function createDescribe<P extends any[]>(message: string, callback: (...args: P) => void): MUIDescribe<P>;