@testing-library/react-native 7.1.0 → 8.0.0

package/build/helpers/makeQueries.js.flow

@@ -0,0 +1,114 @@
+// @flow
+import waitFor from '../waitFor';
+import type { WaitForOptions } from '../waitFor';
+import { ErrorWithStack } from './errors';
+
+type QueryFunction<ArgType, ReturnType> = (
+  instance: ReactTestInstance
+) => (args: ArgType) => ReturnType;
+
+type FindQueryFunction<ArgType, ReturnType> = (
+  instance: ReactTestInstance
+) => (args: ArgType, waitForOptions?: WaitForOptions) => Promise<ReturnType>;
+
+type QueryAllByQuery<QueryArg> = QueryFunction<
+  QueryArg,
+  Array<ReactTestInstance>
+>;
+type QueryByQuery<QueryArg> = QueryFunction<QueryArg, null | ReactTestInstance>;
+
+type GetAllByQuery<QueryArg> = QueryFunction<
+  QueryArg,
+  Array<ReactTestInstance>
+>;
+type GetByQuery<QueryArg> = QueryFunction<QueryArg, ReactTestInstance>;
+
+type FindAllByQuery<QueryArg> = FindQueryFunction<
+  QueryArg,
+  Array<ReactTestInstance>
+>;
+type FindByQuery<QueryArg> = FindQueryFunction<QueryArg, ReactTestInstance>;
+
+export type Queries<QueryArg> = {
+  getBy: GetByQuery<QueryArg>,
+  getAllBy: GetAllByQuery<QueryArg>,
+  queryBy: QueryByQuery<QueryArg>,
+  findBy: FindByQuery<QueryArg>,
+  findAllBy: FindAllByQuery<QueryArg>,
+};
+
+export function makeQueries<QueryArg>(
+  queryAllByQuery: QueryAllByQuery<QueryArg>,
+  getMissingError: (args: QueryArg) => string,
+  getMultipleError: (args: QueryArg) => string
+): Queries<QueryArg> {
+  function getAllByQuery(instance: ReactTestInstance) {
+    return function getAllFn(args: QueryArg) {
+      const results = queryAllByQuery(instance)(args);
+
+      if (results.length === 0) {
+        throw new ErrorWithStack(getMissingError(args), getAllFn);
+      }
+
+      return results;
+    };
+  }
+
+  function queryByQuery(instance: ReactTestInstance) {
+    return function singleQueryFn(args: QueryArg) {
+      const results = queryAllByQuery(instance)(args);
+
+      if (results.length > 1) {
+        throw new ErrorWithStack(getMultipleError(args), singleQueryFn);
+      }
+
+      if (results.length === 0) {
+        return null;
+      }
+
+      return results[0];
+    };
+  }
+
+  function getByQuery(instance: ReactTestInstance) {
+    return function getFn(args: QueryArg) {
+      const results = queryAllByQuery(instance)(args);
+
+      if (results.length > 1) {
+        throw new ErrorWithStack(getMultipleError(args), getFn);
+      }
+
+      if (results.length === 0) {
+        throw new ErrorWithStack(getMissingError(args), getFn);
+      }
+
+      return results[0];
+    };
+  }
+
+  function findAllByQuery(instance: ReactTestInstance) {
+    return function findAllFn(
+      args: QueryArg,
+      waitForOptions?: WaitForOptions = {}
+    ) {
+      return waitFor(() => getAllByQuery(instance)(args), waitForOptions);
+    };
+  }
+
+  function findByQuery(instance: ReactTestInstance) {
+    return function findFn(
+      args: QueryArg,
+      waitForOptions?: WaitForOptions = {}
+    ) {
+      return waitFor(() => getByQuery(instance)(args), waitForOptions);
+    };
+  }
+
+  return {
+    getBy: getByQuery,
+    getAllBy: getAllByQuery,
+    queryBy: queryByQuery,
+    findBy: findByQuery,
+    findAllBy: findAllByQuery,
+  };
+}

package/build/helpers/queryByAPI.js

@@ -3,97 +3,25 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.queryByAPI = exports.UNSAFE_queryAllByProps = exports.UNSAFE_queryAllByType = exports.UNSAFE_queryByProps = exports.UNSAFE_queryByType = exports.queryAllByTestId = exports.queryAllByDisplayValue = exports.queryAllByPlaceholderText = exports.queryAllByText = exports.queryByTestId = exports.queryByDisplayValue = exports.queryByPlaceholderText = exports.queryByText = void 0;
+exports.queryByAPI = exports.UNSAFE_queryAllByProps = exports.UNSAFE_queryAllByType = exports.UNSAFE_queryByProps = exports.UNSAFE_queryByType = void 0;
 
 var React = _interopRequireWildcard(require("react"));
 
 var _getByAPI = require("./getByAPI");
 
-var _errors = require("./errors");
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-const queryByText = instance => function queryByTextFn(text) {
-  try {
-    return (0, _getByAPI.getByText)(instance)(text);
-  } catch (error) {
-    return (0, _errors.createQueryByError)(error, queryByTextFn);
-  }
-};
-
-exports.queryByText = queryByText;
-
-const queryByPlaceholderText = instance => function queryByPlaceholderTextFn(placeholder) {
-  try {
-    return (0, _getByAPI.getByPlaceholderText)(instance)(placeholder);
-  } catch (error) {
-    return (0, _errors.createQueryByError)(error, queryByPlaceholderTextFn);
-  }
-};
-
-exports.queryByPlaceholderText = queryByPlaceholderText;
-
-const queryByDisplayValue = instance => function queryByDisplayValueFn(value) {
-  try {
-    return (0, _getByAPI.getByDisplayValue)(instance)(value);
-  } catch (error) {
-    return (0, _errors.createQueryByError)(error, queryByDisplayValueFn);
-  }
-};
-
-exports.queryByDisplayValue = queryByDisplayValue;
-
-const queryByTestId = instance => function queryByTestIdFn(testID) {
-  try {
-    return (0, _getByAPI.getByTestId)(instance)(testID);
-  } catch (error) {
-    return (0, _errors.createQueryByError)(error, queryByTestIdFn);
-  }
-};
-
-exports.queryByTestId = queryByTestId;
-
-const queryAllByText = instance => text => {
-  try {
-    return (0, _getByAPI.getAllByText)(instance)(text);
-  } catch (error) {
-    return [];
-  }
-};
+var _byTestId = require("./byTestId");
 
-exports.queryAllByText = queryAllByText;
+var _byText = require("./byText");
 
-const queryAllByPlaceholderText = instance => placeholder => {
-  try {
-    return (0, _getByAPI.getAllByPlaceholderText)(instance)(placeholder);
-  } catch (error) {
-    return [];
-  }
-};
+var _byPlaceholderText = require("./byPlaceholderText");
 
-exports.queryAllByPlaceholderText = queryAllByPlaceholderText;
+var _byDisplayValue = require("./byDisplayValue");
 
-const queryAllByDisplayValue = instance => value => {
-  try {
-    return (0, _getByAPI.getAllByDisplayValue)(instance)(value);
-  } catch (error) {
-    return [];
-  }
-};
-
-exports.queryAllByDisplayValue = queryAllByDisplayValue;
+var _errors = require("./errors");
 
-const queryAllByTestId = instance => testID => {
-  try {
-    return (0, _getByAPI.getAllByTestId)(instance)(testID);
-  } catch (error) {
-    return [];
-  }
-};
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 
-exports.queryAllByTestId = queryAllByTestId;
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 const UNSAFE_queryByType = instance => function queryByTypeFn(type) {
   try {
@@ -136,14 +64,14 @@ const UNSAFE_queryAllByProps = instance => props => {
 exports.UNSAFE_queryAllByProps = UNSAFE_queryAllByProps;
 
 const queryByAPI = instance => ({
-  queryByTestId: queryByTestId(instance),
-  queryByText: queryByText(instance),
-  queryByPlaceholderText: queryByPlaceholderText(instance),
-  queryByDisplayValue: queryByDisplayValue(instance),
-  queryAllByTestId: queryAllByTestId(instance),
-  queryAllByText: queryAllByText(instance),
-  queryAllByPlaceholderText: queryAllByPlaceholderText(instance),
-  queryAllByDisplayValue: queryAllByDisplayValue(instance),
+  queryByTestId: (0, _byTestId.queryByTestId)(instance),
+  queryByText: (0, _byText.queryByText)(instance),
+  queryByPlaceholderText: (0, _byPlaceholderText.queryByPlaceholderText)(instance),
+  queryByDisplayValue: (0, _byDisplayValue.queryByDisplayValue)(instance),
+  queryAllByTestId: (0, _byTestId.queryAllByTestId)(instance),
+  queryAllByText: (0, _byText.queryAllByText)(instance),
+  queryAllByPlaceholderText: (0, _byPlaceholderText.queryAllByPlaceholderText)(instance),
+  queryAllByDisplayValue: (0, _byDisplayValue.queryAllByDisplayValue)(instance),
   // Unsafe
   UNSAFE_queryByType: UNSAFE_queryByType(instance),
   UNSAFE_queryAllByType: UNSAFE_queryAllByType(instance),

package/build/helpers/queryByAPI.js.flow

@@ -1,102 +1,63 @@
 // @flow
 import * as React from 'react';
 import {
-  getByTestId,
-  getByText,
-  getByPlaceholderText,
-  getByDisplayValue,
-  getAllByTestId,
-  getAllByText,
-  getAllByPlaceholderText,
-  getAllByDisplayValue,
   UNSAFE_getByType,
   UNSAFE_getByProps,
   UNSAFE_getAllByType,
   UNSAFE_getAllByProps,
 } from './getByAPI';
+import { queryByTestId, queryAllByTestId } from './byTestId';
+import { queryByText, queryAllByText } from './byText';
+import {
+  queryByPlaceholderText,
+  queryAllByPlaceholderText,
+} from './byPlaceholderText';
+import { queryByDisplayValue, queryAllByDisplayValue } from './byDisplayValue';
 import {
   createQueryByError,
   throwRemovedFunctionError,
   throwRenamedFunctionError,
 } from './errors';
 
-export const queryByText = (instance: ReactTestInstance) =>
-  function queryByTextFn(text: string | RegExp) {
-    try {
-      return getByText(instance)(text);
-    } catch (error) {
-      return createQueryByError(error, queryByTextFn);
-    }
-  };
-
-export const queryByPlaceholderText = (instance: ReactTestInstance) =>
-  function queryByPlaceholderTextFn(placeholder: string | RegExp) {
-    try {
-      return getByPlaceholderText(instance)(placeholder);
-    } catch (error) {
-      return createQueryByError(error, queryByPlaceholderTextFn);
-    }
-  };
-
-export const queryByDisplayValue = (instance: ReactTestInstance) =>
-  function queryByDisplayValueFn(value: string | RegExp) {
-    try {
-      return getByDisplayValue(instance)(value);
-    } catch (error) {
-      return createQueryByError(error, queryByDisplayValueFn);
-    }
-  };
-
-export const queryByTestId = (instance: ReactTestInstance) =>
-  function queryByTestIdFn(testID: string | RegExp) {
-    try {
-      return getByTestId(instance)(testID);
-    } catch (error) {
-      return createQueryByError(error, queryByTestIdFn);
-    }
-  };
-
-export const queryAllByText = (instance: ReactTestInstance) => (
-  text: string | RegExp
-) => {
-  try {
-    return getAllByText(instance)(text);
-  } catch (error) {
-    return [];
-  }
-};
-
-export const queryAllByPlaceholderText = (instance: ReactTestInstance) => (
-  placeholder: string | RegExp
-) => {
-  try {
-    return getAllByPlaceholderText(instance)(placeholder);
-  } catch (error) {
-    return [];
-  }
-};
-
-export const queryAllByDisplayValue = (instance: ReactTestInstance) => (
-  value: string | RegExp
-) => {
-  try {
-    return getAllByDisplayValue(instance)(value);
-  } catch (error) {
-    return [];
-  }
-};
-
-export const queryAllByTestId = (instance: ReactTestInstance) => (
-  testID: string | RegExp
-) => {
-  try {
-    return getAllByTestId(instance)(testID);
-  } catch (error) {
-    return [];
-  }
-};
-
-export const UNSAFE_queryByType = (instance: ReactTestInstance) =>
+export type QueryByAPI = {|
+  queryByText: (name: string | RegExp) => ReactTestInstance | null,
+  queryByPlaceholderText: (
+    placeholder: string | RegExp
+  ) => ReactTestInstance | null,
+  queryByDisplayValue: (value: string | RegExp) => ReactTestInstance | null,
+  queryByTestId: (testID: string | RegExp) => ReactTestInstance | null,
+  queryAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance>,
+  queryAllByText: (text: string | RegExp) => Array<ReactTestInstance>,
+  queryAllByPlaceholderText: (
+    placeholder: string | RegExp
+  ) => Array<ReactTestInstance>,
+  queryAllByDisplayValue: (value: string | RegExp) => Array<ReactTestInstance>,
+
+  // Unsafe aliases
+  UNSAFE_queryByType: <P>(
+    type: React.ComponentType<P>
+  ) => ReactTestInstance | null,
+  UNSAFE_queryAllByType: <P>(
+    type: React.ComponentType<P>
+  ) => Array<ReactTestInstance>,
+  UNSAFE_queryByProps: (props: { [string]: any }) => ReactTestInstance | null,
+  UNSAFE_queryAllByProps: (props: {
+    [string]: any,
+  }) => Array<ReactTestInstance>,
+  queryByName: () => void,
+  queryByType: () => void,
+  queryByProps: () => void,
+  queryAllByName: () => void,
+  queryAllByType: () => void,
+  queryAllByProps: () => void,
+
+  queryByPlaceholder: () => void,
+  queryAllByPlaceholder: () => void,
+|};
+
+export const UNSAFE_queryByType = (
+  instance: ReactTestInstance
+): ((type: React.ComponentType<any>) => ReactTestInstance | null) =>
   function queryByTypeFn(type: React.ComponentType<any>) {
     try {
       return UNSAFE_getByType(instance)(type);
@@ -105,7 +66,9 @@ export const UNSAFE_queryByType = (instance: ReactTestInstance) =>
     }
   };
 
-export const UNSAFE_queryByProps = (instance: ReactTestInstance) =>
+export const UNSAFE_queryByProps = (
+  instance: ReactTestInstance
+): ((props: { [propName: string]: any }) => ReactTestInstance | null) =>
   function queryByPropsFn(props: { [propName: string]: any }) {
     try {
       return UNSAFE_getByProps(instance)(props);
@@ -114,7 +77,9 @@ export const UNSAFE_queryByProps = (instance: ReactTestInstance) =>
     }
   };
 
-export const UNSAFE_queryAllByType = (instance: ReactTestInstance) => (
+export const UNSAFE_queryAllByType = (
+  instance: ReactTestInstance
+): ((type: React.ComponentType<any>) => Array<ReactTestInstance>) => (
   type: React.ComponentType<any>
 ) => {
   try {
@@ -124,9 +89,11 @@ export const UNSAFE_queryAllByType = (instance: ReactTestInstance) => (
   }
 };
 
-export const UNSAFE_queryAllByProps = (instance: ReactTestInstance) => (props: {
+export const UNSAFE_queryAllByProps = (
+  instance: ReactTestInstance
+): ((props: {
   [propName: string]: any,
-}) => {
+}) => Array<ReactTestInstance>) => (props: { [propName: string]: any }) => {
   try {
     return UNSAFE_getAllByProps(instance)(props);
   } catch (error) {
@@ -134,7 +101,7 @@ export const UNSAFE_queryAllByProps = (instance: ReactTestInstance) => (props: {
   }
 };
 
-export const queryByAPI = (instance: ReactTestInstance) => ({
+export const queryByAPI = (instance: ReactTestInstance): QueryByAPI => ({
   queryByTestId: queryByTestId(instance),
   queryByText: queryByText(instance),
   queryByPlaceholderText: queryByPlaceholderText(instance),

package/build/helpers/timers.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runWithRealTimers = runWithRealTimers;
+exports.setTimeout = exports.setImmediate = exports.clearTimeout = exports.jestFakeTimersAreEnabled = void 0;
+// Most content of this file sourced directly from https://github.com/testing-library/dom-testing-library/blob/main/src/helpers.js
+
+/* globals jest */
+const globalObj = typeof window === 'undefined' ? global : window; // Currently this fn only supports jest timers, but it could support other test runners in the future.
+
+function runWithRealTimers(callback) {
+  const fakeTimersType = getJestFakeTimersType();
+
+  if (fakeTimersType) {
+    jest.useRealTimers();
+  }
+
+  const callbackReturnValue = callback();
+
+  if (fakeTimersType) {
+    jest.useFakeTimers(fakeTimersType);
+  }
+
+  return callbackReturnValue;
+}
+
+function getJestFakeTimersType() {
+  // istanbul ignore if
+  if (typeof jest === 'undefined' || typeof globalObj.setTimeout === 'undefined') {
+    return null;
+  }
+
+  if (typeof globalObj.setTimeout._isMockFunction !== 'undefined' && globalObj.setTimeout._isMockFunction) {
+    return 'legacy';
+  }
+
+  if (typeof globalObj.setTimeout.clock !== 'undefined' && // $FlowIgnore[prop-missing]
+  typeof jest.getRealSystemTime !== 'undefined') {
+    try {
+      // jest.getRealSystemTime is only supported for Jest's `modern` fake timers and otherwise throws
+      // $FlowExpectedError
+      jest.getRealSystemTime();
+      return 'modern';
+    } catch {// not using Jest's modern fake timers
+    }
+  }
+
+  return null;
+}
+
+const jestFakeTimersAreEnabled = () => Boolean(getJestFakeTimersType()); // we only run our tests in node, and setImmediate is supported in node.
+
+
+exports.jestFakeTimersAreEnabled = jestFakeTimersAreEnabled;
+
+function setImmediatePolyfill(fn) {
+  return globalObj.setTimeout(fn, 0);
+}
+
+function bindTimeFunctions() {
+  return {
+    clearTimeoutFn: globalObj.clearTimeout,
+    setImmediateFn: globalObj.setImmediate || setImmediatePolyfill,
+    setTimeoutFn: globalObj.setTimeout
+  };
+}
+
+const {
+  clearTimeoutFn,
+  setImmediateFn,
+  setTimeoutFn
+} = runWithRealTimers(bindTimeFunctions);
+exports.setTimeout = setTimeoutFn;
+exports.setImmediate = setImmediateFn;
+exports.clearTimeout = clearTimeoutFn;

package/build/helpers/timers.js.flow

@@ -0,0 +1,88 @@
+// Most content of this file sourced directly from https://github.com/testing-library/dom-testing-library/blob/main/src/helpers.js
+// @flow
+/* globals jest */
+
+const globalObj = typeof window === 'undefined' ? global : window;
+
+// Currently this fn only supports jest timers, but it could support other test runners in the future.
+function runWithRealTimers<T>(callback: () => T): T {
+  const fakeTimersType = getJestFakeTimersType();
+  if (fakeTimersType) {
+    jest.useRealTimers();
+  }
+
+  const callbackReturnValue = callback();
+
+  if (fakeTimersType) {
+    jest.useFakeTimers(fakeTimersType);
+  }
+
+  return callbackReturnValue;
+}
+
+function getJestFakeTimersType() {
+  // istanbul ignore if
+  if (
+    typeof jest === 'undefined' ||
+    typeof globalObj.setTimeout === 'undefined'
+  ) {
+    return null;
+  }
+
+  if (
+    typeof globalObj.setTimeout._isMockFunction !== 'undefined' &&
+    globalObj.setTimeout._isMockFunction
+  ) {
+    return 'legacy';
+  }
+
+  if (
+    typeof globalObj.setTimeout.clock !== 'undefined' &&
+    // $FlowIgnore[prop-missing]
+    typeof jest.getRealSystemTime !== 'undefined'
+  ) {
+    try {
+      // jest.getRealSystemTime is only supported for Jest's `modern` fake timers and otherwise throws
+      // $FlowExpectedError
+      jest.getRealSystemTime();
+      return 'modern';
+    } catch {
+      // not using Jest's modern fake timers
+    }
+  }
+  return null;
+}
+
+const jestFakeTimersAreEnabled = (): boolean =>
+  Boolean(getJestFakeTimersType());
+
+// we only run our tests in node, and setImmediate is supported in node.
+function setImmediatePolyfill(fn) {
+  return globalObj.setTimeout(fn, 0);
+}
+
+type BindTimeFunctions = {
+  clearTimeoutFn: typeof clearTimeout,
+  setImmediateFn: typeof setImmediate,
+  setTimeoutFn: typeof setTimeout,
+};
+
+function bindTimeFunctions(): BindTimeFunctions {
+  return {
+    clearTimeoutFn: globalObj.clearTimeout,
+    setImmediateFn: globalObj.setImmediate || setImmediatePolyfill,
+    setTimeoutFn: globalObj.setTimeout,
+  };
+}
+
+const { clearTimeoutFn, setImmediateFn, setTimeoutFn } = (runWithRealTimers(
+  bindTimeFunctions
+): BindTimeFunctions);
+
+export {
+  runWithRealTimers,
+  jestFakeTimersAreEnabled,
+  clearTimeoutFn as clearTimeout,
+  setImmediateFn as setImmediate,
+  setTimeoutFn as setTimeout,
+};

package/build/index.js

@@ -8,6 +8,7 @@ var _pure = require("./pure");
 
 Object.keys(_pure).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pure[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {

package/build/render.js

@@ -19,7 +19,7 @@ var _queryByAPI = require("./helpers/queryByAPI");
 
 var _findByAPI = require("./helpers/findByAPI");
 
-var _a11yAPI = _interopRequireDefault(require("./helpers/a11yAPI"));
+var _a11yAPI = require("./helpers/a11yAPI");
 
 var _debugShallow = _interopRequireDefault(require("./helpers/debugShallow"));
 
@@ -48,16 +48,23 @@ function render(component, {
   } : undefined);
   const update = updateWithAct(renderer, wrap);
   const instance = renderer.root;
-  (0, _cleanup.addToCleanupQueue)(renderer.unmount);
+
+  const unmount = () => {
+    (0, _act.default)(() => {
+      renderer.unmount();
+    });
+  };
+
+  (0, _cleanup.addToCleanupQueue)(unmount);
   return { ...(0, _getByAPI.getByAPI)(instance),
     ...(0, _queryByAPI.queryByAPI)(instance),
     ...(0, _findByAPI.findByAPI)(instance),
-    ...(0, _a11yAPI.default)(instance),
+    ...(0, _a11yAPI.a11yAPI)(instance),
     update,
+    unmount,
     container: instance,
     rerender: update,
     // alias for `update`
-    unmount: renderer.unmount,
     toJSON: renderer.toJSON,
     debug: debug(instance, renderer)
   };