@mui/internal-test-utils 2.0.15 → 2.0.16

package/{src/chai.types.ts → chai.types.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/chai.types.js

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

package/chaiPlugin.d.ts

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

package/chaiPlugin.js

@@ -0,0 +1,287 @@
+"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");
+var _domAccessibilityApi = require("dom-accessibility-api");
+var _formatUtil = _interopRequireDefault(require("format-util"));
+var _string = require("es-toolkit/string");
+var _assertionError = require("assertion-error");
+require("./chai.types");
+var _env = require("./env");
+// 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) {
+    /**
+     * @param {string[]} expectedMessages
+     */
+    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 = typeof expectedMessagesInput === 'string' ? [expectedMessagesInput] : expectedMessagesInput.slice();
+        const unexpectedMessages = [];
+        // TODO Remove type once MUI X enables noImplicitAny
+        let caughtError = 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.` + 'Expected no call to console.error but provided 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 (!actualMessage.includes(expectedMessage)) {
+            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 {
+          callback();
+        } catch (error) {
+          caughtError = error;
+        } finally {
+          // eslint-disable-next-line no-console
+          console[methodName] = originalMethod;
+
+          // 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 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);
+          }
+        }
+      } else {
+        // nothing to do in prod
+        // If there are still console calls than our test setup throws.
+        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/{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,64 @@
+"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
+  });
+});

package/createDOM.d.ts

@@ -0,0 +1,2 @@
+export = createDOM;
+declare function createDOM(): void;

package/{src/createDOM.js → createDOM.js}

@@ -1,29 +1,21 @@
-const { JSDOM } = require('jsdom');
+"use strict";
+
+const {
+  JSDOM
+} = require('jsdom');
 
 // We can use jsdom-global at some point if maintaining these lists is a burden.
 const whitelist = [
-  // used by React's experimental cache API
-  // Always including it to reduce churn when switching between React builds
-  'AbortController',
-  // required for fake getComputedStyle
-  'CSSStyleDeclaration',
-  'Element',
-  'Event',
-  'TouchEvent',
-  'Image',
-  'HTMLElement',
-  'HTMLInputElement',
-  'Node',
-  'Performance',
-  'document',
-  'DocumentFragment',
-];
+// used by React's experimental cache API
+// Always including it to reduce churn when switching between React builds
+'AbortController',
+// required for fake getComputedStyle
+'CSSStyleDeclaration', 'Element', 'Event', 'TouchEvent', 'Image', 'HTMLElement', 'HTMLInputElement', 'Node', 'Performance', 'document', 'DocumentFragment'];
 const blacklist = ['sessionStorage', 'localStorage'];
-
 function createDOM() {
   const dom = new JSDOM('', {
     pretendToBeVisual: true,
-    url: 'http://localhost',
+    url: 'http://localhost'
   });
   globalThis.window = dom.window;
   // Not yet supported: https://github.com/jsdom/jsdom/issues/2152
@@ -31,37 +23,27 @@ function createDOM() {
     constructor(instance) {
       this.instance = instance;
     }
-
     get identifier() {
       return this.instance.identifier;
     }
-
     get pageX() {
       return this.instance.pageX;
     }
-
     get pageY() {
       return this.instance.pageY;
     }
-
     get clientX() {
       return this.instance.clientX;
     }
-
     get clientY() {
       return this.instance.clientY;
     }
   }
   globalThis.window.Touch = Touch;
-
-  Object.keys(dom.window)
-    .filter((key) => !blacklist.includes(key))
-    .concat(whitelist)
-    .forEach((key) => {
-      if (typeof globalThis[key] === 'undefined') {
-        globalThis[key] = dom.window[key];
-      }
-    });
+  Object.keys(dom.window).filter(key => !blacklist.includes(key)).concat(whitelist).forEach(key => {
+    if (typeof globalThis[key] === 'undefined') {
+      globalThis[key] = dom.window[key];
+    }
+  });
 }
-
-module.exports = createDOM;
+module.exports = createDOM;

package/createDescribe.d.ts

@@ -0,0 +1,7 @@
+type MUIDescribe<P extends any[]> = {
+  (...args: P): void;
+  skip: (...args: P) => void;
+  only: (...args: P) => void;
+};
+declare const _default: <P extends any[]>(message: string, callback: (...args: P) => void) => MUIDescribe<P>;
+export default _default;

package/createDescribe.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _vitest = require("vitest");
+var _default = (message, callback) => {
+  const muiDescribe = (...args) => {
+    (0, _vitest.describe)(message, () => {
+      callback(...args);
+    });
+  };
+  muiDescribe.skip = (...args) => {
+    _vitest.describe.skip(message, () => {
+      callback(...args);
+    });
+  };
+  muiDescribe.only = (...args) => {
+    _vitest.describe.only(message, () => {
+      callback(...args);
+    });
+  };
+  return muiDescribe;
+};
+exports.default = _default;