@testing-library/react-native 9.1.0 → 10.0.1

package/build/{helpers/byText.js → queries/text.js}

@@ -3,21 +3,21 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.queryByText = exports.queryAllByText = exports.getByText = exports.getAllByText = exports.findByText = exports.findAllByText = void 0;
+exports.bindByTextQueries = void 0;
 
 var React = _interopRequireWildcard(require("react"));
 
-var _matches = require("../matches");
+var _errors = require("../helpers/errors");
 
-var _makeQueries = require("./makeQueries");
+var _filterNodeByType = require("../helpers/filterNodeByType");
 
-var _filterNodeByType = require("./filterNodeByType");
+var _matches = require("../matches");
 
-var _errors = require("./errors");
+var _makeQueries = require("./makeQueries");
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-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; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && 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 getChildrenAsText = (children, TextComponent) => {
   const textContent = [];
@@ -78,26 +78,32 @@ const getNodeByText = (node, text, options = {}) => {
   }
 };
 
-const queryAllByText = instance => function queryAllByTextFn(text, queryOptions) {
-  const results = instance.findAll(node => getNodeByText(node, text, queryOptions));
+const queryAllByText = instance => function queryAllByTextFn(text, options) {
+  const results = instance.findAll(node => getNodeByText(node, text, options));
   return results;
 };
 
-exports.queryAllByText = queryAllByText;
-
 const getMultipleError = text => `Found multiple elements with text: ${String(text)}`;
 
 const getMissingError = text => `Unable to find an element with text: ${String(text)}`;
 
 const {
-  getBy: getByText,
-  getAllBy: getAllByText,
-  queryBy: queryByText,
-  findBy: findByText,
-  findAllBy: findAllByText
+  getBy,
+  getAllBy,
+  queryBy,
+  queryAllBy,
+  findBy,
+  findAllBy
 } = (0, _makeQueries.makeQueries)(queryAllByText, getMissingError, getMultipleError);
-exports.findAllByText = findAllByText;
-exports.findByText = findByText;
-exports.queryByText = queryByText;
-exports.getAllByText = getAllByText;
-exports.getByText = getByText;
+
+const bindByTextQueries = instance => ({
+  getByText: getBy(instance),
+  getAllByText: getAllBy(instance),
+  queryByText: queryBy(instance),
+  queryAllByText: queryAllBy(instance),
+  findByText: findBy(instance),
+  findAllByText: findAllBy(instance)
+});
+
+exports.bindByTextQueries = bindByTextQueries;
+//# sourceMappingURL=text.js.map

package/build/queries/text.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/queries/text.ts"],"names":["getChildrenAsText","children","TextComponent","textContent","React","Children","forEach","child","push","toString","props","Fragment","getNodeByText","node","text","options","Text","require","isTextComponent","textChildren","textToTest","join","exact","normalizer","error","queryAllByText","instance","queryAllByTextFn","results","findAll","getMultipleError","String","getMissingError","getBy","getAllBy","queryBy","queryAllBy","findBy","findAllBy","bindByTextQueries","getByText","getAllByText","queryByText","findByText","findAllByText"],"mappings":"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","sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport * as React from 'react';\nimport { createLibraryNotSupportedError } from '../helpers/errors';\nimport { filterNodeByType } from '../helpers/filterNodeByType';\nimport { matches, TextMatch } from '../matches';\nimport type { NormalizerFn } from '../matches';\nimport { makeQueries } from './makeQueries';\nimport type {\n  FindAllByQuery,\n  FindByQuery,\n  GetAllByQuery,\n  GetByQuery,\n  QueryAllByQuery,\n  QueryByQuery,\n} from './makeQueries';\n\nexport type TextMatchOptions = {\n  exact?: boolean;\n  normalizer?: NormalizerFn;\n};\n\nconst getChildrenAsText = (\n  children: React.ReactChild[],\n  TextComponent: React.ComponentType\n) => {\n  const textContent: string[] = [];\n  React.Children.forEach(children, (child) => {\n    if (typeof child === 'string') {\n      textContent.push(child);\n      return;\n    }\n\n    if (typeof child === 'number') {\n      textContent.push(child.toString());\n      return;\n    }\n\n    if (child?.props?.children) {\n      // Bail on traversing text children down the tree if current node (child)\n      // has no text. In such situations, react-test-renderer will traverse down\n      // this tree in a separate call and run this query again. As a result, the\n      // query will match the deepest text node that matches requested text.\n      if (filterNodeByType(child, TextComponent)) {\n        return;\n      }\n\n      if (filterNodeByType(child, React.Fragment)) {\n        textContent.push(\n          ...getChildrenAsText(child.props.children, TextComponent)\n        );\n      }\n    }\n  });\n\n  return textContent;\n};\n\nconst getNodeByText = (\n  node: ReactTestInstance,\n  text: TextMatch,\n  options: TextMatchOptions = {}\n) => {\n  try {\n    const { Text } = require('react-native');\n    const isTextComponent = filterNodeByType(node, Text);\n    if (isTextComponent) {\n      const textChildren = getChildrenAsText(node.props.children, Text);\n      if (textChildren) {\n        const textToTest = textChildren.join('');\n        const { exact, normalizer } = options;\n        return matches(text, textToTest, normalizer, exact);\n      }\n    }\n    return false;\n  } catch (error) {\n    throw createLibraryNotSupportedError(error);\n  }\n};\n\nconst queryAllByText = (\n  instance: ReactTestInstance\n): ((\n  text: TextMatch,\n  options?: TextMatchOptions\n) => Array<ReactTestInstance>) =>\n  function queryAllByTextFn(text, options) {\n    const results = instance.findAll((node) =>\n      getNodeByText(node, text, options)\n    );\n\n    return results;\n  };\n\nconst getMultipleError = (text: TextMatch) =>\n  `Found multiple elements with text: ${String(text)}`;\nconst getMissingError = (text: TextMatch) =>\n  `Unable to find an element with text: ${String(text)}`;\n\nconst { getBy, getAllBy, queryBy, queryAllBy, findBy, findAllBy } = makeQueries(\n  queryAllByText,\n  getMissingError,\n  getMultipleError\n);\n\nexport type ByTextQueries = {\n  getByText: GetByQuery<TextMatch, TextMatchOptions>;\n  getAllByText: GetAllByQuery<TextMatch, TextMatchOptions>;\n  queryByText: QueryByQuery<TextMatch, TextMatchOptions>;\n  queryAllByText: QueryAllByQuery<TextMatch, TextMatchOptions>;\n  findByText: FindByQuery<TextMatch, TextMatchOptions>;\n  findAllByText: FindAllByQuery<TextMatch, TextMatchOptions>;\n};\n\nexport const bindByTextQueries = (\n  instance: ReactTestInstance\n): ByTextQueries => ({\n  getByText: getBy(instance),\n  getAllByText: getAllBy(instance),\n  queryByText: queryBy(instance),\n  queryAllByText: queryAllBy(instance),\n  findByText: findBy(instance),\n  findAllByText: findAllBy(instance),\n});\n"],"file":"text.js"}

package/build/queries/unsafeProps.d.ts

@@ -0,0 +1,16 @@
+import type { ReactTestInstance } from 'react-test-renderer';
+export declare type UnsafeByPropsQueries = {
+    UNSAFE_getByProps: (props: {
+        [key: string]: any;
+    }) => ReactTestInstance;
+    UNSAFE_getAllByProps: (props: {
+        [key: string]: any;
+    }) => Array<ReactTestInstance>;
+    UNSAFE_queryByProps: (props: {
+        [key: string]: any;
+    }) => ReactTestInstance | null;
+    UNSAFE_queryAllByProps: (props: {
+        [key: string]: any;
+    }) => Array<ReactTestInstance>;
+};
+export declare const bindUnsafeByPropsQueries: (instance: ReactTestInstance) => UnsafeByPropsQueries;

package/build/queries/unsafeProps.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bindUnsafeByPropsQueries = void 0;
+
+var _prettyFormat = _interopRequireDefault(require("pretty-format"));
+
+var _errors = require("../helpers/errors");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const UNSAFE_getByProps = instance => function getByPropsFn(props) {
+  try {
+    return instance.findByProps(props);
+  } catch (error) {
+    throw new _errors.ErrorWithStack((0, _errors.prepareErrorMessage)(error), getByPropsFn);
+  }
+};
+
+const UNSAFE_getAllByProps = instance => function getAllByPropsFn(props) {
+  const results = instance.findAllByProps(props);
+
+  if (results.length === 0) {
+    throw new _errors.ErrorWithStack(`No instances found with props:\n${(0, _prettyFormat.default)(props)}`, getAllByPropsFn);
+  }
+
+  return results;
+};
+
+const UNSAFE_queryByProps = instance => function queryByPropsFn(props) {
+  try {
+    return UNSAFE_getByProps(instance)(props);
+  } catch (error) {
+    return (0, _errors.createQueryByError)(error, queryByPropsFn);
+  }
+};
+
+const UNSAFE_queryAllByProps = instance => props => {
+  try {
+    return UNSAFE_getAllByProps(instance)(props);
+  } catch (error) {
+    return [];
+  }
+}; // Unsafe aliases
+
+
+// TODO: migrate to makeQueries pattern
+const bindUnsafeByPropsQueries = instance => ({
+  UNSAFE_getByProps: UNSAFE_getByProps(instance),
+  UNSAFE_getAllByProps: UNSAFE_getAllByProps(instance),
+  UNSAFE_queryByProps: UNSAFE_queryByProps(instance),
+  UNSAFE_queryAllByProps: UNSAFE_queryAllByProps(instance)
+});
+
+exports.bindUnsafeByPropsQueries = bindUnsafeByPropsQueries;
+//# sourceMappingURL=unsafeProps.js.map

package/build/queries/unsafeProps.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/queries/unsafeProps.ts"],"names":["UNSAFE_getByProps","instance","getByPropsFn","props","findByProps","error","ErrorWithStack","UNSAFE_getAllByProps","getAllByPropsFn","results","findAllByProps","length","UNSAFE_queryByProps","queryByPropsFn","UNSAFE_queryAllByProps","bindUnsafeByPropsQueries"],"mappings":";;;;;;;AACA;;AACA;;;;AAGA,MAAMA,iBAAiB,GACrBC,QADwB,IAGxB,SAASC,YAAT,CAAsBC,KAAtB,EAA0D;AACxD,MAAI;AACF,WAAOF,QAAQ,CAACG,WAAT,CAAqBD,KAArB,CAAP;AACD,GAFD,CAEE,OAAOE,KAAP,EAAc;AACd,UAAM,IAAIC,sBAAJ,CAAmB,iCAAoBD,KAApB,CAAnB,EAA+CH,YAA/C,CAAN;AACD;AACF,CATH;;AAWA,MAAMK,oBAAoB,GACxBN,QAD2B,IAG3B,SAASO,eAAT,CAAyBL,KAAzB,EAA6D;AAC3D,QAAMM,OAAO,GAAGR,QAAQ,CAACS,cAAT,CAAwBP,KAAxB,CAAhB;;AACA,MAAIM,OAAO,CAACE,MAAR,KAAmB,CAAvB,EAA0B;AACxB,UAAM,IAAIL,sBAAJ,CACH,mCAAkC,2BAAaH,KAAb,CAAoB,EADnD,EAEJK,eAFI,CAAN;AAID;;AACD,SAAOC,OAAP;AACD,CAZH;;AAcA,MAAMG,mBAAmB,GACvBX,QAD0B,IAG1B,SAASY,cAAT,CAAwBV,KAAxB,EAA4D;AAC1D,MAAI;AACF,WAAOH,iBAAiB,CAACC,QAAD,CAAjB,CAA4BE,KAA5B,CAAP;AACD,GAFD,CAEE,OAAOE,KAAP,EAAc;AACd,WAAO,gCAAmBA,KAAnB,EAA0BQ,cAA1B,CAAP;AACD;AACF,CATH;;AAWA,MAAMC,sBAAsB,GAC1Bb,QAD6B,IAIKE,KAAD,IAAwC;AACzE,MAAI;AACF,WAAOI,oBAAoB,CAACN,QAAD,CAApB,CAA+BE,KAA/B,CAAP;AACD,GAFD,CAEE,OAAOE,KAAP,EAAc;AACd,WAAO,EAAP;AACD;AACF,CAVD,C,CAYA;;;AAcA;AACO,MAAMU,wBAAwB,GACnCd,QADsC,KAEZ;AAC1BD,EAAAA,iBAAiB,EAAEA,iBAAiB,CAACC,QAAD,CADV;AAE1BM,EAAAA,oBAAoB,EAAEA,oBAAoB,CAACN,QAAD,CAFhB;AAG1BW,EAAAA,mBAAmB,EAAEA,mBAAmB,CAACX,QAAD,CAHd;AAI1Ba,EAAAA,sBAAsB,EAAEA,sBAAsB,CAACb,QAAD;AAJpB,CAFY,CAAjC","sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport prettyFormat from 'pretty-format';\nimport { ErrorWithStack, prepareErrorMessage } from '../helpers/errors';\nimport { createQueryByError } from '../helpers/errors';\n\nconst UNSAFE_getByProps = (\n  instance: ReactTestInstance\n): ((props: { [propName: string]: any }) => ReactTestInstance) =>\n  function getByPropsFn(props: { [propName: string]: any }) {\n    try {\n      return instance.findByProps(props);\n    } catch (error) {\n      throw new ErrorWithStack(prepareErrorMessage(error), getByPropsFn);\n    }\n  };\n\nconst UNSAFE_getAllByProps = (\n  instance: ReactTestInstance\n): ((props: { [propName: string]: any }) => Array<ReactTestInstance>) =>\n  function getAllByPropsFn(props: { [propName: string]: any }) {\n    const results = instance.findAllByProps(props);\n    if (results.length === 0) {\n      throw new ErrorWithStack(\n        `No instances found with props:\\n${prettyFormat(props)}`,\n        getAllByPropsFn\n      );\n    }\n    return results;\n  };\n\nconst UNSAFE_queryByProps = (\n  instance: ReactTestInstance\n): ((props: { [propName: string]: any }) => ReactTestInstance | null) =>\n  function queryByPropsFn(props: { [propName: string]: any }) {\n    try {\n      return UNSAFE_getByProps(instance)(props);\n    } catch (error) {\n      return createQueryByError(error, queryByPropsFn);\n    }\n  };\n\nconst UNSAFE_queryAllByProps = (\n  instance: ReactTestInstance\n): ((props: {\n  [propName: string]: any;\n}) => Array<ReactTestInstance>) => (props: { [propName: string]: any }) => {\n  try {\n    return UNSAFE_getAllByProps(instance)(props);\n  } catch (error) {\n    return [];\n  }\n};\n\n// Unsafe aliases\nexport type UnsafeByPropsQueries = {\n  UNSAFE_getByProps: (props: { [key: string]: any }) => ReactTestInstance;\n  UNSAFE_getAllByProps: (props: {\n    [key: string]: any;\n  }) => Array<ReactTestInstance>;\n  UNSAFE_queryByProps: (props: {\n    [key: string]: any;\n  }) => ReactTestInstance | null;\n  UNSAFE_queryAllByProps: (props: {\n    [key: string]: any;\n  }) => Array<ReactTestInstance>;\n};\n\n// TODO: migrate to makeQueries pattern\nexport const bindUnsafeByPropsQueries = (\n  instance: ReactTestInstance\n): UnsafeByPropsQueries => ({\n  UNSAFE_getByProps: UNSAFE_getByProps(instance),\n  UNSAFE_getAllByProps: UNSAFE_getAllByProps(instance),\n  UNSAFE_queryByProps: UNSAFE_queryByProps(instance),\n  UNSAFE_queryAllByProps: UNSAFE_queryAllByProps(instance),\n});\n"],"file":"unsafeProps.js"}

package/build/queries/unsafeType.d.ts

@@ -0,0 +1,9 @@
+import type { ReactTestInstance } from 'react-test-renderer';
+import * as React from 'react';
+export declare type UnsafeByTypeQueries = {
+    UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance;
+    UNSAFE_getAllByType: <P>(type: React.ComponentType<P>) => Array<ReactTestInstance>;
+    UNSAFE_queryByType: <P>(type: React.ComponentType<P>) => ReactTestInstance | null;
+    UNSAFE_queryAllByType: <P>(type: React.ComponentType<P>) => Array<ReactTestInstance>;
+};
+export declare const bindUnsafeByTypeQueries: (instance: ReactTestInstance) => UnsafeByTypeQueries;

package/build/queries/unsafeType.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bindUnsafeByTypeQueries = void 0;
+
+var _errors = require("../helpers/errors");
+
+const UNSAFE_getByType = instance => function getByTypeFn(type) {
+  try {
+    return instance.findByType(type);
+  } catch (error) {
+    throw new _errors.ErrorWithStack((0, _errors.prepareErrorMessage)(error), getByTypeFn);
+  }
+};
+
+const UNSAFE_getAllByType = instance => function getAllByTypeFn(type) {
+  const results = instance.findAllByType(type);
+
+  if (results.length === 0) {
+    throw new _errors.ErrorWithStack('No instances found', getAllByTypeFn);
+  }
+
+  return results;
+};
+
+const UNSAFE_queryByType = instance => function queryByTypeFn(type) {
+  try {
+    return UNSAFE_getByType(instance)(type);
+  } catch (error) {
+    return (0, _errors.createQueryByError)(error, queryByTypeFn);
+  }
+};
+
+const UNSAFE_queryAllByType = instance => type => {
+  try {
+    return UNSAFE_getAllByType(instance)(type);
+  } catch (error) {
+    return [];
+  }
+}; // Unsafe aliases
+
+
+// TODO: migrate to makeQueries pattern
+const bindUnsafeByTypeQueries = instance => ({
+  UNSAFE_getByType: UNSAFE_getByType(instance),
+  UNSAFE_getAllByType: UNSAFE_getAllByType(instance),
+  UNSAFE_queryByType: UNSAFE_queryByType(instance),
+  UNSAFE_queryAllByType: UNSAFE_queryAllByType(instance)
+});
+
+exports.bindUnsafeByTypeQueries = bindUnsafeByTypeQueries;
+//# sourceMappingURL=unsafeType.js.map

package/build/queries/unsafeType.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/queries/unsafeType.ts"],"names":["UNSAFE_getByType","instance","getByTypeFn","type","findByType","error","ErrorWithStack","UNSAFE_getAllByType","getAllByTypeFn","results","findAllByType","length","UNSAFE_queryByType","queryByTypeFn","UNSAFE_queryAllByType","bindUnsafeByTypeQueries"],"mappings":";;;;;;;AAEA;;AAGA,MAAMA,gBAAgB,GACpBC,QADuB,IAGvB,SAASC,WAAT,CAAqBC,IAArB,EAAqD;AACnD,MAAI;AACF,WAAOF,QAAQ,CAACG,UAAT,CAAoBD,IAApB,CAAP;AACD,GAFD,CAEE,OAAOE,KAAP,EAAc;AACd,UAAM,IAAIC,sBAAJ,CAAmB,iCAAoBD,KAApB,CAAnB,EAA+CH,WAA/C,CAAN;AACD;AACF,CATH;;AAWA,MAAMK,mBAAmB,GACvBN,QAD0B,IAG1B,SAASO,cAAT,CAAwBL,IAAxB,EAAwD;AACtD,QAAMM,OAAO,GAAGR,QAAQ,CAACS,aAAT,CAAuBP,IAAvB,CAAhB;;AACA,MAAIM,OAAO,CAACE,MAAR,KAAmB,CAAvB,EAA0B;AACxB,UAAM,IAAIL,sBAAJ,CAAmB,oBAAnB,EAAyCE,cAAzC,CAAN;AACD;;AACD,SAAOC,OAAP;AACD,CATH;;AAWA,MAAMG,kBAAkB,GACtBX,QADyB,IAGzB,SAASY,aAAT,CAAuBV,IAAvB,EAAuD;AACrD,MAAI;AACF,WAAOH,gBAAgB,CAACC,QAAD,CAAhB,CAA2BE,IAA3B,CAAP;AACD,GAFD,CAEE,OAAOE,KAAP,EAAc;AACd,WAAO,gCAAmBA,KAAnB,EAA0BQ,aAA1B,CAAP;AACD;AACF,CATH;;AAWA,MAAMC,qBAAqB,GACzBb,QAD4B,IAG5BE,IADmE,IAEhE;AACH,MAAI;AACF,WAAOI,mBAAmB,CAACN,QAAD,CAAnB,CAA8BE,IAA9B,CAAP;AACD,GAFD,CAEE,OAAOE,KAAP,EAAc;AACd,WAAO,EAAP;AACD;AACF,CAVD,C,CAYA;;;AAcA;AACO,MAAMU,uBAAuB,GAClCd,QADqC,KAEZ;AACzBD,EAAAA,gBAAgB,EAAEA,gBAAgB,CAACC,QAAD,CADT;AAEzBM,EAAAA,mBAAmB,EAAEA,mBAAmB,CAACN,QAAD,CAFf;AAGzBW,EAAAA,kBAAkB,EAAEA,kBAAkB,CAACX,QAAD,CAHb;AAIzBa,EAAAA,qBAAqB,EAAEA,qBAAqB,CAACb,QAAD;AAJnB,CAFY,CAAhC","sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport * as React from 'react';\nimport { ErrorWithStack, prepareErrorMessage } from '../helpers/errors';\nimport { createQueryByError } from '../helpers/errors';\n\nconst UNSAFE_getByType = (\n  instance: ReactTestInstance\n): ((type: React.ComponentType<any>) => ReactTestInstance) =>\n  function getByTypeFn(type: React.ComponentType<any>) {\n    try {\n      return instance.findByType(type);\n    } catch (error) {\n      throw new ErrorWithStack(prepareErrorMessage(error), getByTypeFn);\n    }\n  };\n\nconst UNSAFE_getAllByType = (\n  instance: ReactTestInstance\n): ((type: React.ComponentType<any>) => Array<ReactTestInstance>) =>\n  function getAllByTypeFn(type: React.ComponentType<any>) {\n    const results = instance.findAllByType(type);\n    if (results.length === 0) {\n      throw new ErrorWithStack('No instances found', getAllByTypeFn);\n    }\n    return results;\n  };\n\nconst UNSAFE_queryByType = (\n  instance: ReactTestInstance\n): ((type: React.ComponentType<any>) => ReactTestInstance | null) =>\n  function queryByTypeFn(type: React.ComponentType<any>) {\n    try {\n      return UNSAFE_getByType(instance)(type);\n    } catch (error) {\n      return createQueryByError(error, queryByTypeFn);\n    }\n  };\n\nconst UNSAFE_queryAllByType = (\n  instance: ReactTestInstance\n): ((type: React.ComponentType<any>) => Array<ReactTestInstance>) => (\n  type: React.ComponentType<any>\n) => {\n  try {\n    return UNSAFE_getAllByType(instance)(type);\n  } catch (error) {\n    return [];\n  }\n};\n\n// Unsafe aliases\nexport type UnsafeByTypeQueries = {\n  UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance;\n  UNSAFE_getAllByType: <P>(\n    type: React.ComponentType<P>\n  ) => Array<ReactTestInstance>;\n  UNSAFE_queryByType: <P>(\n    type: React.ComponentType<P>\n  ) => ReactTestInstance | null;\n  UNSAFE_queryAllByType: <P>(\n    type: React.ComponentType<P>\n  ) => Array<ReactTestInstance>;\n};\n\n// TODO: migrate to makeQueries pattern\nexport const bindUnsafeByTypeQueries = (\n  instance: ReactTestInstance\n): UnsafeByTypeQueries => ({\n  UNSAFE_getByType: UNSAFE_getByType(instance),\n  UNSAFE_getAllByType: UNSAFE_getAllByType(instance),\n  UNSAFE_queryByType: UNSAFE_queryByType(instance),\n  UNSAFE_queryAllByType: UNSAFE_queryAllByType(instance),\n});\n"],"file":"unsafeType.js"}

package/build/render.d.ts

@@ -0,0 +1,135 @@
+import TestRenderer from 'react-test-renderer';
+import * as React from 'react';
+declare type Options = {
+    wrapper?: React.ComponentType<any>;
+    createNodeMock?: (element: React.ReactElement) => any;
+};
+/**
+ * Renders test component deeply using react-test-renderer and exposes helpers
+ * to assert on the output.
+ */
+export default function render<T>(component: React.ReactElement<T>, { wrapper: Wrapper, createNodeMock }?: Options): {
+    update: (component: React.ReactElement<any, string | React.JSXElementConstructor<any>>) => void;
+    unmount: () => void;
+    container: TestRenderer.ReactTestInstance;
+    rerender: (component: React.ReactElement<any, string | React.JSXElementConstructor<any>>) => void;
+    toJSON: () => TestRenderer.ReactTestRendererJSON | TestRenderer.ReactTestRendererJSON[] | null;
+    debug: DebugFunction;
+    getByLabelText: (label: import("./matches").TextMatch) => TestRenderer.ReactTestInstance;
+    getAllByLabelText: (label: import("./matches").TextMatch) => TestRenderer.ReactTestInstance[];
+    queryByLabelText: (label: import("./matches").TextMatch) => TestRenderer.ReactTestInstance | null;
+    queryAllByLabelText: (label: import("./matches").TextMatch) => TestRenderer.ReactTestInstance[];
+    findByLabelText: (label: import("./matches").TextMatch, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<TestRenderer.ReactTestInstance>;
+    findAllByLabelText: (label: import("./matches").TextMatch, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<TestRenderer.ReactTestInstance[]>;
+    getByA11yHint: (a11yHint: import("./matches").TextMatch) => TestRenderer.ReactTestInstance;
+    getByHintText: (a11yHint: import("./matches").TextMatch) => TestRenderer.ReactTestInstance;
+    getAllByA11yHint: (a11yHint: import("./matches").TextMatch) => TestRenderer.ReactTestInstance[];
+    getAllByHintText: (a11yHint: import("./matches").TextMatch) => TestRenderer.ReactTestInstance[];
+    queryByA11yHint: (a11yHint: import("./matches").TextMatch) => TestRenderer.ReactTestInstance | null;
+    queryByHintText: (a11yHint: import("./matches").TextMatch) => TestRenderer.ReactTestInstance | null;
+    queryAllByA11yHint: (a11yHint: import("./matches").TextMatch) => TestRenderer.ReactTestInstance[];
+    queryAllByHintText: (a11yHint: import("./matches").TextMatch) => TestRenderer.ReactTestInstance[];
+    findByA11yHint: (a11yHint: import("./matches").TextMatch, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<TestRenderer.ReactTestInstance>;
+    findByHintText: (a11yHint: import("./matches").TextMatch, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<TestRenderer.ReactTestInstance>;
+    findAllByA11yHint: (a11yHint: import("./matches").TextMatch, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<TestRenderer.ReactTestInstance[]>;
+    findAllByHintText: (a11yHint: import("./matches").TextMatch, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<TestRenderer.ReactTestInstance[]>;
+    getByRole: (role: RegExp | import("react-native").AccessibilityRole) => TestRenderer.ReactTestInstance;
+    getAllByRole: (role: RegExp | import("react-native").AccessibilityRole) => TestRenderer.ReactTestInstance[];
+    queryByRole: (role: RegExp | import("react-native").AccessibilityRole) => TestRenderer.ReactTestInstance | null;
+    queryAllByRole: (role: RegExp | import("react-native").AccessibilityRole) => TestRenderer.ReactTestInstance[];
+    findByRole: (role: import("react-native").AccessibilityRole, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<TestRenderer.ReactTestInstance>;
+    findAllByRole: (role: import("react-native").AccessibilityRole, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<TestRenderer.ReactTestInstance[]>;
+    getByA11yStates: (accessibilityStateKey: keyof import("react-native").AccessibilityState | (keyof import("react-native").AccessibilityState)[]) => TestRenderer.ReactTestInstance;
+    getAllByA11yStates: (accessibilityStateKey: keyof import("react-native").AccessibilityState | (keyof import("react-native").AccessibilityState)[]) => TestRenderer.ReactTestInstance[];
+    queryByA11yStates: (accessibilityStateKey: keyof import("react-native").AccessibilityState | (keyof import("react-native").AccessibilityState)[]) => TestRenderer.ReactTestInstance | null;
+    queryAllByA11yStates: (accessibilityStateKey: keyof import("react-native").AccessibilityState | (keyof import("react-native").AccessibilityState)[]) => TestRenderer.ReactTestInstance[];
+    findByA11yStates: (accessibilityStateKey: keyof import("react-native").AccessibilityState, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<TestRenderer.ReactTestInstance>;
+    findAllByA11yStates: (accessibilityStateKey: keyof import("react-native").AccessibilityState, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<TestRenderer.ReactTestInstance[]>;
+    getByA11yState: (accessibilityState: import("react-native").AccessibilityState) => TestRenderer.ReactTestInstance;
+    getAllByA11yState: (accessibilityState: import("react-native").AccessibilityState) => TestRenderer.ReactTestInstance[];
+    queryByA11yState: (accessibilityState: import("react-native").AccessibilityState) => TestRenderer.ReactTestInstance | null;
+    queryAllByA11yState: (accessibilityState: import("react-native").AccessibilityState) => TestRenderer.ReactTestInstance[];
+    findByA11yState: (accessibilityState: import("react-native").AccessibilityState, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<TestRenderer.ReactTestInstance>;
+    findAllByA11yState: (accessibilityState: import("react-native").AccessibilityState, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<TestRenderer.ReactTestInstance[]>;
+    getByA11yValue: (a11yValue: {
+        min?: number | undefined;
+        max?: number | undefined;
+        now?: number | undefined;
+        text?: string | undefined;
+    }) => TestRenderer.ReactTestInstance;
+    getAllByA11yValue: (a11yValue: {
+        min?: number | undefined;
+        max?: number | undefined;
+        now?: number | undefined;
+        text?: string | undefined;
+    }) => TestRenderer.ReactTestInstance[];
+    queryByA11yValue: (a11yValue: {
+        min?: number | undefined;
+        max?: number | undefined;
+        now?: number | undefined;
+        text?: string | undefined;
+    }) => TestRenderer.ReactTestInstance | null;
+    queryAllByA11yValue: (a11yValue: {
+        min?: number | undefined;
+        max?: number | undefined;
+        now?: number | undefined;
+        text?: string | undefined;
+    }) => TestRenderer.ReactTestInstance[];
+    findByA11yValue: (a11yValue: {
+        min?: number | undefined;
+        max?: number | undefined;
+        now?: number | undefined;
+        text?: string | undefined;
+    }, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<TestRenderer.ReactTestInstance>;
+    findAllByA11yValue: (a11yValue: {
+        min?: number | undefined;
+        max?: number | undefined;
+        now?: number | undefined;
+        text?: string | undefined;
+    }, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<TestRenderer.ReactTestInstance[]>;
+    UNSAFE_getByProps: (props: {
+        [key: string]: any;
+    }) => TestRenderer.ReactTestInstance;
+    UNSAFE_getAllByProps: (props: {
+        [key: string]: any;
+    }) => TestRenderer.ReactTestInstance[];
+    UNSAFE_queryByProps: (props: {
+        [key: string]: any;
+    }) => TestRenderer.ReactTestInstance | null;
+    UNSAFE_queryAllByProps: (props: {
+        [key: string]: any;
+    }) => TestRenderer.ReactTestInstance[];
+    UNSAFE_getByType: <P>(type: React.ComponentType<P>) => TestRenderer.ReactTestInstance;
+    UNSAFE_getAllByType: <P_1>(type: React.ComponentType<P_1>) => TestRenderer.ReactTestInstance[];
+    UNSAFE_queryByType: <P_2>(type: React.ComponentType<P_2>) => TestRenderer.ReactTestInstance | null;
+    UNSAFE_queryAllByType: <P_3>(type: React.ComponentType<P_3>) => TestRenderer.ReactTestInstance[];
+    getByPlaceholderText: import("./queries/makeQueries").GetByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    getAllByPlaceholderText: import("./queries/makeQueries").GetAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryByPlaceholderText: import("./queries/makeQueries").QueryByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryAllByPlaceholderText: import("./queries/makeQueries").QueryAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findByPlaceholderText: import("./queries/makeQueries").FindByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findAllByPlaceholderText: import("./queries/makeQueries").FindAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    getByDisplayValue: import("./queries/makeQueries").GetByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    getAllByDisplayValue: import("./queries/makeQueries").GetAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryByDisplayValue: import("./queries/makeQueries").QueryByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryAllByDisplayValue: import("./queries/makeQueries").QueryAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findByDisplayValue: import("./queries/makeQueries").FindByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findAllByDisplayValue: import("./queries/makeQueries").FindAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    getByTestId: import("./queries/makeQueries").GetByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    getAllByTestId: import("./queries/makeQueries").GetAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryByTestId: import("./queries/makeQueries").QueryByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryAllByTestId: import("./queries/makeQueries").QueryAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findByTestId: import("./queries/makeQueries").FindByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findAllByTestId: import("./queries/makeQueries").FindAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    getByText: import("./queries/makeQueries").GetByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    getAllByText: import("./queries/makeQueries").GetAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryByText: import("./queries/makeQueries").QueryByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryAllByText: import("./queries/makeQueries").QueryAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findByText: import("./queries/makeQueries").FindByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findAllByText: import("./queries/makeQueries").FindAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+};
+interface DebugFunction {
+    (message?: string): void;
+    shallow: (message?: string) => void;
+}
+export {};

package/build/render.js

@@ -5,33 +5,25 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = render;
 
-var React = _interopRequireWildcard(require("react"));
-
 var _reactTestRenderer = _interopRequireDefault(require("react-test-renderer"));
 
+var React = _interopRequireWildcard(require("react"));
+
 var _act = _interopRequireDefault(require("./act"));
 
 var _cleanup = require("./cleanup");
 
-var _getByAPI = require("./helpers/getByAPI");
-
-var _queryByAPI = require("./helpers/queryByAPI");
-
-var _findByAPI = require("./helpers/findByAPI");
-
-var _a11yAPI = require("./helpers/a11yAPI");
-
 var _debugShallow = _interopRequireDefault(require("./helpers/debugShallow"));
 
 var _debugDeep = _interopRequireDefault(require("./helpers/debugDeep"));
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _within = require("./within");
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-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; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && 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; }
 
-// eslint-disable-line import/no-extraneous-dependencies
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
  * Renders test component deeply using react-test-renderer and exposes helpers
@@ -56,10 +48,7 @@ function render(component, {
   };
 
   (0, _cleanup.addToCleanupQueue)(unmount);
-  return { ...(0, _getByAPI.getByAPI)(instance),
-    ...(0, _queryByAPI.queryByAPI)(instance),
-    ...(0, _findByAPI.findByAPI)(instance),
-    ...(0, _a11yAPI.a11yAPI)(instance),
+  return { ...(0, _within.getQueriesForElement)(instance),
     update,
     unmount,
     container: instance,
@@ -74,7 +63,8 @@ function renderWithAct(component, options) {
   let renderer;
   (0, _act.default)(() => {
     renderer = _reactTestRenderer.default.create(component, options);
-  });
+  }); // @ts-ignore act is sync, so renderer is always initialised here
+
   return renderer;
 }
 
@@ -88,10 +78,15 @@ function updateWithAct(renderer, wrap) {
 
 function debug(instance, renderer) {
   function debugImpl(message) {
-    return (0, _debugDeep.default)(renderer.toJSON(), message);
+    const json = renderer.toJSON();
+
+    if (json) {
+      return (0, _debugDeep.default)(json, message);
+    }
   }
 
   debugImpl.shallow = message => (0, _debugShallow.default)(instance, message);
 
   return debugImpl;
-}
+}
+//# sourceMappingURL=render.js.map

package/build/render.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/render.tsx"],"names":["render","component","wrapper","Wrapper","createNodeMock","wrap","innerElement","renderer","renderWithAct","undefined","update","updateWithAct","instance","root","unmount","container","rerender","toJSON","debug","options","TestRenderer","create","debugImpl","message","json","shallow"],"mappings":";;;;;;;AAAA;;AAEA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;;;AAUA;AACA;AACA;AACA;AACe,SAASA,MAAT,CACbC,SADa,EAEb;AAAEC,EAAAA,OAAO,EAAEC,OAAX;AAAoBC,EAAAA;AAApB,IAAgD,EAFnC,EAGb;AACA,QAAMC,IAAI,GAAIC,YAAD,IACXH,OAAO,gBAAG,oBAAC,OAAD,QAAUG,YAAV,CAAH,GAAuCA,YADhD;;AAGA,QAAMC,QAAQ,GAAGC,aAAa,CAC5BH,IAAI,CAACJ,SAAD,CADwB,EAE5BG,cAAc,GAAG;AAAEA,IAAAA;AAAF,GAAH,GAAwBK,SAFV,CAA9B;AAIA,QAAMC,MAAM,GAAGC,aAAa,CAACJ,QAAD,EAAWF,IAAX,CAA5B;AACA,QAAMO,QAAQ,GAAGL,QAAQ,CAACM,IAA1B;;AACA,QAAMC,OAAO,GAAG,MAAM;AACpB,sBAAI,MAAM;AACRP,MAAAA,QAAQ,CAACO,OAAT;AACD,KAFD;AAGD,GAJD;;AAMA,kCAAkBA,OAAlB;AAEA,SAAO,EACL,GAAG,kCAAqBF,QAArB,CADE;AAELF,IAAAA,MAFK;AAGLI,IAAAA,OAHK;AAILC,IAAAA,SAAS,EAAEH,QAJN;AAKLI,IAAAA,QAAQ,EAAEN,MALL;AAKa;AAClBO,IAAAA,MAAM,EAAEV,QAAQ,CAACU,MANZ;AAOLC,IAAAA,KAAK,EAAEA,KAAK,CAACN,QAAD,EAAWL,QAAX;AAPP,GAAP;AASD;;AAED,SAASC,aAAT,CACEP,SADF,EAEEkB,OAFF,EAGqB;AACnB,MAAIZ,QAAJ;AAEA,oBAAI,MAAM;AACRA,IAAAA,QAAQ,GAAGa,2BAAaC,MAAb,CAAoBpB,SAApB,EAA+BkB,OAA/B,CAAX;AACD,GAFD,EAHmB,CAOnB;;AACA,SAAOZ,QAAP;AACD;;AAED,SAASI,aAAT,CACEJ,QADF,EAEEF,IAFF,EAGE;AACA,SAAO,UAAUJ,SAAV,EAAyC;AAC9C,sBAAI,MAAM;AACRM,MAAAA,QAAQ,CAACG,MAAT,CAAgBL,IAAI,CAACJ,SAAD,CAApB;AACD,KAFD;AAGD,GAJD;AAKD;;AAOD,SAASiB,KAAT,CACEN,QADF,EAEEL,QAFF,EAGiB;AACf,WAASe,SAAT,CAAmBC,OAAnB,EAAqC;AACnC,UAAMC,IAAI,GAAGjB,QAAQ,CAACU,MAAT,EAAb;;AACA,QAAIO,IAAJ,EAAU;AACR,aAAO,wBAAUA,IAAV,EAAgBD,OAAhB,CAAP;AACD;AACF;;AACDD,EAAAA,SAAS,CAACG,OAAV,GAAqBF,OAAD,IAAsB,2BAAaX,QAAb,EAAuBW,OAAvB,CAA1C;;AACA,SAAOD,SAAP;AACD","sourcesContent":["import TestRenderer from 'react-test-renderer';\nimport type { ReactTestInstance, ReactTestRenderer } from 'react-test-renderer';\nimport * as React from 'react';\nimport act from './act';\nimport { addToCleanupQueue } from './cleanup';\nimport debugShallow from './helpers/debugShallow';\nimport debugDeep from './helpers/debugDeep';\nimport { getQueriesForElement } from './within';\n\ntype Options = {\n  wrapper?: React.ComponentType<any>;\n  createNodeMock?: (element: React.ReactElement) => any;\n};\ntype TestRendererOptions = {\n  createNodeMock: (element: React.ReactElement) => any;\n};\n\n/**\n * Renders test component deeply using react-test-renderer and exposes helpers\n * to assert on the output.\n */\nexport default function render<T>(\n  component: React.ReactElement<T>,\n  { wrapper: Wrapper, createNodeMock }: Options = {}\n) {\n  const wrap = (innerElement: React.ReactElement) =>\n    Wrapper ? <Wrapper>{innerElement}</Wrapper> : innerElement;\n\n  const renderer = renderWithAct(\n    wrap(component),\n    createNodeMock ? { createNodeMock } : undefined\n  );\n  const update = updateWithAct(renderer, wrap);\n  const instance = renderer.root;\n  const unmount = () => {\n    act(() => {\n      renderer.unmount();\n    });\n  };\n\n  addToCleanupQueue(unmount);\n\n  return {\n    ...getQueriesForElement(instance),\n    update,\n    unmount,\n    container: instance,\n    rerender: update, // alias for `update`\n    toJSON: renderer.toJSON,\n    debug: debug(instance, renderer),\n  };\n}\n\nfunction renderWithAct(\n  component: React.ReactElement,\n  options?: TestRendererOptions\n): ReactTestRenderer {\n  let renderer: ReactTestRenderer;\n\n  act(() => {\n    renderer = TestRenderer.create(component, options);\n  });\n\n  // @ts-ignore act is sync, so renderer is always initialised here\n  return renderer;\n}\n\nfunction updateWithAct(\n  renderer: ReactTestRenderer,\n  wrap: (innerElement: React.ReactElement) => React.ReactElement\n) {\n  return function (component: React.ReactElement) {\n    act(() => {\n      renderer.update(wrap(component));\n    });\n  };\n}\n\ninterface DebugFunction {\n  (message?: string): void;\n  shallow: (message?: string) => void;\n}\n\nfunction debug(\n  instance: ReactTestInstance,\n  renderer: ReactTestRenderer\n): DebugFunction {\n  function debugImpl(message?: string) {\n    const json = renderer.toJSON();\n    if (json) {\n      return debugDeep(json, message);\n    }\n  }\n  debugImpl.shallow = (message?: string) => debugShallow(instance, message);\n  return debugImpl;\n}\n"],"file":"render.js"}

package/build/renderHook.d.ts

@@ -0,0 +1,17 @@
+import type { ComponentType } from 'react';
+interface RenderHookResult<Result, Props> {
+    rerender: (props: Props) => void;
+    result: {
+        current: Result;
+    };
+    unmount: () => void;
+}
+declare type RenderHookOptions<Props> = Props extends object | string | number | boolean ? {
+    initialProps: Props;
+    wrapper?: ComponentType<any>;
+} : {
+    wrapper?: ComponentType<any>;
+    initialProps?: never;
+} | undefined;
+export declare function renderHook<Result, Props>(renderCallback: (props: Props) => Result, options?: RenderHookOptions<Props>): RenderHookResult<Result, Props>;
+export {};

package/build/renderHook.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderHook = renderHook;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _render = _interopRequireDefault(require("./render"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function renderHook(renderCallback, options) {
+  const initialProps = options === null || options === void 0 ? void 0 : options.initialProps;
+  const wrapper = options === null || options === void 0 ? void 0 : options.wrapper;
+
+  const result = /*#__PURE__*/_react.default.createRef();
+
+  function TestComponent({
+    renderCallbackProps
+  }) {
+    const renderResult = renderCallback(renderCallbackProps);
+
+    _react.default.useEffect(() => {
+      result.current = renderResult;
+    });
+
+    return null;
+  }
+
+  const {
+    rerender: baseRerender,
+    unmount
+  } = (0, _render.default)(
+  /*#__PURE__*/
+  // @ts-expect-error since option can be undefined, initialProps can be undefined when it should'nt
+  _react.default.createElement(TestComponent, {
+    renderCallbackProps: initialProps
+  }), {
+    wrapper
+  });
+
+  function rerender(rerenderCallbackProps) {
+    return baseRerender( /*#__PURE__*/_react.default.createElement(TestComponent, {
+      renderCallbackProps: rerenderCallbackProps
+    }));
+  } // @ts-expect-error result is ill typed because ref is initialized to null
+
+
+  return {
+    result,
+    rerender,
+    unmount
+  };
+}
+//# sourceMappingURL=renderHook.js.map

package/build/renderHook.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/renderHook.tsx"],"names":["renderHook","renderCallback","options","initialProps","wrapper","result","React","createRef","TestComponent","renderCallbackProps","renderResult","useEffect","current","rerender","baseRerender","unmount","rerenderCallbackProps"],"mappings":";;;;;;;AAAA;;AAEA;;;;AAeO,SAASA,UAAT,CACLC,cADK,EAELC,OAFK,EAG4B;AACjC,QAAMC,YAAY,GAAGD,OAAH,aAAGA,OAAH,uBAAGA,OAAO,CAAEC,YAA9B;AACA,QAAMC,OAAO,GAAGF,OAAH,aAAGA,OAAH,uBAAGA,OAAO,CAAEE,OAAzB;;AAEA,QAAMC,MAA6C,gBAAGC,eAAMC,SAAN,EAAtD;;AAEA,WAASC,aAAT,CAAuB;AACrBC,IAAAA;AADqB,GAAvB,EAIG;AACD,UAAMC,YAAY,GAAGT,cAAc,CAACQ,mBAAD,CAAnC;;AAEAH,mBAAMK,SAAN,CAAgB,MAAM;AACpBN,MAAAA,MAAM,CAACO,OAAP,GAAiBF,YAAjB;AACD,KAFD;;AAIA,WAAO,IAAP;AACD;;AAED,QAAM;AAAEG,IAAAA,QAAQ,EAAEC,YAAZ;AAA0BC,IAAAA;AAA1B,MAAsC;AAAA;AAC1C;AACA,+BAAC,aAAD;AAAe,IAAA,mBAAmB,EAAEZ;AAApC,IAF0C,EAG1C;AAAEC,IAAAA;AAAF,GAH0C,CAA5C;;AAMA,WAASS,QAAT,CAAkBG,qBAAlB,EAAgD;AAC9C,WAAOF,YAAY,eACjB,6BAAC,aAAD;AAAe,MAAA,mBAAmB,EAAEE;AAApC,MADiB,CAAnB;AAGD,GA9BgC,CAgCjC;;;AACA,SAAO;AAAEX,IAAAA,MAAF;AAAUQ,IAAAA,QAAV;AAAoBE,IAAAA;AAApB,GAAP;AACD","sourcesContent":["import React from 'react';\nimport type { ComponentType } from 'react';\nimport render from './render';\n\ninterface RenderHookResult<Result, Props> {\n  rerender: (props: Props) => void;\n  result: { current: Result };\n  unmount: () => void;\n}\n\ntype RenderHookOptions<Props> = Props extends object | string | number | boolean\n  ? {\n      initialProps: Props;\n      wrapper?: ComponentType<any>;\n    }\n  : { wrapper?: ComponentType<any>; initialProps?: never } | undefined;\n\nexport function renderHook<Result, Props>(\n  renderCallback: (props: Props) => Result,\n  options?: RenderHookOptions<Props>\n): RenderHookResult<Result, Props> {\n  const initialProps = options?.initialProps;\n  const wrapper = options?.wrapper;\n\n  const result: React.MutableRefObject<Result | null> = React.createRef();\n\n  function TestComponent({\n    renderCallbackProps,\n  }: {\n    renderCallbackProps: Props;\n  }) {\n    const renderResult = renderCallback(renderCallbackProps);\n\n    React.useEffect(() => {\n      result.current = renderResult;\n    });\n\n    return null;\n  }\n\n  const { rerender: baseRerender, unmount } = render(\n    // @ts-expect-error since option can be undefined, initialProps can be undefined when it should'nt\n    <TestComponent renderCallbackProps={initialProps} />,\n    { wrapper }\n  );\n\n  function rerender(rerenderCallbackProps: Props) {\n    return baseRerender(\n      <TestComponent renderCallbackProps={rerenderCallbackProps} />\n    );\n  }\n\n  // @ts-expect-error result is ill typed because ref is initialized to null\n  return { result, rerender, unmount };\n}\n"],"file":"renderHook.js"}

package/build/shallow.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { ReactTestInstance } from 'react-test-renderer';
+/**
+ * Renders test component shallowly using react-test-renderer/shallow
+ */
+export declare function shallowInternal(instance: ReactTestInstance | React.ReactElement<any>): {
+    output: any;
+};

package/build/shallow.js

@@ -4,19 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.shallowInternal = shallowInternal;
-exports.default = shallow;
 
 var React = _interopRequireWildcard(require("react"));
 
 var _shallow = _interopRequireDefault(require("react-test-renderer/shallow"));
 
-var _errors = require("./helpers/errors");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-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; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && 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; }
 
 // eslint-disable-line import/no-extraneous-dependencies
 
@@ -30,7 +27,4 @@ function shallowInternal(instance) {
     output: renderer.getRenderOutput()
   };
 }
-
-function shallow(_) {
-  (0, _errors.throwRemovedFunctionError)('shallow', 'migration-v2#removed-global-shallow-function');
-}
+//# sourceMappingURL=shallow.js.map

package/build/shallow.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shallow.ts"],"names":["shallowInternal","instance","renderer","ShallowRenderer","render","React","createElement","type","props","output","getRenderOutput"],"mappings":";;;;;;;AAAA;;AAEA;;;;;;;;AAA2D;;AAE3D;AACA;AACA;AACO,SAASA,eAAT,CACLC,QADK,EAEY;AACjB,QAAMC,QAAQ,GAAG,IAAKC,gBAAL,EAAjB;AAEAD,EAAAA,QAAQ,CAACE,MAAT,eAAgBC,KAAK,CAACC,aAAN,CAAoBL,QAAQ,CAACM,IAA7B,EAAmCN,QAAQ,CAACO,KAA5C,CAAhB;AAEA,SAAO;AACLC,IAAAA,MAAM,EAAEP,QAAQ,CAACQ,eAAT;AADH,GAAP;AAGD","sourcesContent":["import * as React from 'react';\nimport { ReactTestInstance } from 'react-test-renderer';\nimport ShallowRenderer from 'react-test-renderer/shallow'; // eslint-disable-line import/no-extraneous-dependencies\n\n/**\n * Renders test component shallowly using react-test-renderer/shallow\n */\nexport function shallowInternal(\n  instance: ReactTestInstance | React.ReactElement<any>\n): { output: any } {\n  const renderer = new (ShallowRenderer as any)();\n\n  renderer.render(React.createElement(instance.type, instance.props));\n\n  return {\n    output: renderer.getRenderOutput(),\n  };\n}\n"],"file":"shallow.js"}