@testing-library/react-native 9.2.0 → 10.1.0

package/build/{helpers → queries}/makeQueries.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.makeQueries = makeQueries;
 
-var _waitFor = _interopRequireDefault(require("../waitFor"));
+var _errors = require("../helpers/errors");
 
-var _errors = require("./errors");
+var _waitFor = _interopRequireDefault(require("../waitFor"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -39,11 +39,11 @@ Example:
 
 function makeQueries(queryAllByQuery, getMissingError, getMultipleError) {
   function getAllByQuery(instance) {
-    return function getAllFn(args, queryOptions) {
-      const results = queryAllByQuery(instance)(args, queryOptions);
+    return function getAllFn(predicate, options) {
+      const results = queryAllByQuery(instance)(predicate, options);
 
       if (results.length === 0) {
-        throw new _errors.ErrorWithStack(getMissingError(args), getAllFn);
+        throw new _errors.ErrorWithStack(getMissingError(predicate), getAllFn);
       }
 
       return results;
@@ -51,11 +51,11 @@ function makeQueries(queryAllByQuery, getMissingError, getMultipleError) {
   }
 
   function queryByQuery(instance) {
-    return function singleQueryFn(args, queryOptions) {
-      const results = queryAllByQuery(instance)(args, queryOptions);
+    return function singleQueryFn(predicate, options) {
+      const results = queryAllByQuery(instance)(predicate, options);
 
       if (results.length > 1) {
-        throw new _errors.ErrorWithStack(getMultipleError(args), singleQueryFn);
+        throw new _errors.ErrorWithStack(getMultipleError(predicate), singleQueryFn);
       }
 
       if (results.length === 0) {
@@ -67,15 +67,15 @@ function makeQueries(queryAllByQuery, getMissingError, getMultipleError) {
   }
 
   function getByQuery(instance) {
-    return function getFn(args, queryOptions) {
-      const results = queryAllByQuery(instance)(args, queryOptions);
+    return function getFn(predicate, options) {
+      const results = queryAllByQuery(instance)(predicate, options);
 
       if (results.length > 1) {
-        throw new _errors.ErrorWithStack(getMultipleError(args), getFn);
+        throw new _errors.ErrorWithStack(getMultipleError(predicate), getFn);
       }
 
       if (results.length === 0) {
-        throw new _errors.ErrorWithStack(getMissingError(args), getFn);
+        throw new _errors.ErrorWithStack(getMissingError(predicate), getFn);
       }
 
       return results[0];
@@ -83,18 +83,18 @@ function makeQueries(queryAllByQuery, getMissingError, getMultipleError) {
   }
 
   function findAllByQuery(instance) {
-    return function findAllFn(args, queryOptions, waitForOptions = {}) {
+    return function findAllFn(predicate, queryOptions, waitForOptions = {}) {
       const deprecatedWaitForOptions = extractDeprecatedWaitForOptionUsage(queryOptions);
-      return (0, _waitFor.default)(() => getAllByQuery(instance)(args, queryOptions), { ...deprecatedWaitForOptions,
+      return (0, _waitFor.default)(() => getAllByQuery(instance)(predicate, queryOptions), { ...deprecatedWaitForOptions,
         ...waitForOptions
       });
     };
   }
 
   function findByQuery(instance) {
-    return function findFn(args, queryOptions, waitForOptions = {}) {
+    return function findFn(predicate, queryOptions, waitForOptions = {}) {
       const deprecatedWaitForOptions = extractDeprecatedWaitForOptionUsage(queryOptions);
-      return (0, _waitFor.default)(() => getByQuery(instance)(args, queryOptions), { ...deprecatedWaitForOptions,
+      return (0, _waitFor.default)(() => getByQuery(instance)(predicate, queryOptions), { ...deprecatedWaitForOptions,
         ...waitForOptions
       });
     };
@@ -104,6 +104,7 @@ function makeQueries(queryAllByQuery, getMissingError, getMultipleError) {
     getBy: getByQuery,
     getAllBy: getAllByQuery,
     queryBy: queryByQuery,
+    queryAllBy: queryAllByQuery,
     findBy: findByQuery,
     findAllBy: findAllByQuery
   };

package/build/queries/makeQueries.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/queries/makeQueries.ts"],"names":["deprecatedKeys","extractDeprecatedWaitForOptionUsage","queryOptions","waitForOptions","timeout","interval","stackTraceError","forEach","key","option","console","warn","toString","makeQueries","queryAllByQuery","getMissingError","getMultipleError","getAllByQuery","instance","getAllFn","predicate","options","results","length","ErrorWithStack","queryByQuery","singleQueryFn","getByQuery","getFn","findAllByQuery","findAllFn","deprecatedWaitForOptions","findByQuery","findFn","getBy","getAllBy","queryBy","queryAllBy","findBy","findAllBy"],"mappings":"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","sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport { ErrorWithStack } from '../helpers/errors';\nimport waitFor from '../waitFor';\nimport type { WaitForOptions } from '../waitFor';\n\nexport type GetByQuery<Predicate, Options> = (\n  predicate: Predicate,\n  options?: Options\n) => ReactTestInstance;\n\nexport type GetAllByQuery<Predicate, Options> = (\n  predicate: Predicate,\n  options?: Options\n) => ReactTestInstance[];\n\nexport type QueryByQuery<Predicate, Options> = (\n  predicate: Predicate,\n  options?: Options\n) => ReactTestInstance | null;\n\nexport type QueryAllByQuery<Predicate, Options> = (\n  predicate: Predicate,\n  options?: Options\n) => ReactTestInstance[];\n\nexport type FindByQuery<Predicate, Options> = (\n  predicate: Predicate,\n  options?: Options & WaitForOptions,\n  waitForOptions?: WaitForOptions\n) => Promise<ReactTestInstance>;\n\nexport type FindAllByQuery<Predicate, Options> = (\n  predicate: Predicate,\n  options?: Options & WaitForOptions,\n  waitForOptions?: WaitForOptions\n) => Promise<ReactTestInstance[]>;\n\ntype UnboundQuery<Query> = (instance: ReactTestInstance) => Query;\n\nexport type UnboundQueries<Predicate, Options> = {\n  getBy: UnboundQuery<GetByQuery<Predicate, Options>>;\n  getAllBy: UnboundQuery<GetAllByQuery<Predicate, Options>>;\n  queryBy: UnboundQuery<QueryByQuery<Predicate, Options>>;\n  queryAllBy: UnboundQuery<QueryAllByQuery<Predicate, Options>>;\n  findBy: UnboundQuery<FindByQuery<Predicate, Options>>;\n  findAllBy: UnboundQuery<FindAllByQuery<Predicate, Options>>;\n};\n\n// The WaitForOptions has been moved to the second option param of findBy* methods with the adding of TextMatchOptions\n// To make the migration easier and avoid a breaking change, keep reading this options from the first param but warn\nconst deprecatedKeys: (keyof WaitForOptions)[] = [\n  'timeout',\n  'interval',\n  'stackTraceError',\n];\nconst extractDeprecatedWaitForOptionUsage = (queryOptions?: WaitForOptions) => {\n  if (queryOptions) {\n    const waitForOptions: WaitForOptions = {\n      timeout: queryOptions.timeout,\n      interval: queryOptions.interval,\n      stackTraceError: queryOptions.stackTraceError,\n    };\n    deprecatedKeys.forEach((key) => {\n      const option = queryOptions[key];\n      if (option) {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `Use of option \"${key}\" in a findBy* query's second parameter, TextMatchOptions, is deprecated. Please pass this option in the third, WaitForOptions, parameter. \nExample: \n\n  findByText(text, {}, { ${key}: ${option.toString()} })`\n        );\n      }\n    });\n    return waitForOptions;\n  }\n};\n\nexport function makeQueries<Predicate, Options>(\n  queryAllByQuery: UnboundQuery<QueryAllByQuery<Predicate, Options>>,\n  getMissingError: (predicate: Predicate) => string,\n  getMultipleError: (predicate: Predicate) => string\n): UnboundQueries<Predicate, Options> {\n  function getAllByQuery(instance: ReactTestInstance) {\n    return function getAllFn(predicate: Predicate, options?: Options) {\n      const results = queryAllByQuery(instance)(predicate, options);\n\n      if (results.length === 0) {\n        throw new ErrorWithStack(getMissingError(predicate), getAllFn);\n      }\n\n      return results;\n    };\n  }\n\n  function queryByQuery(instance: ReactTestInstance) {\n    return function singleQueryFn(predicate: Predicate, options?: Options) {\n      const results = queryAllByQuery(instance)(predicate, options);\n\n      if (results.length > 1) {\n        throw new ErrorWithStack(getMultipleError(predicate), singleQueryFn);\n      }\n\n      if (results.length === 0) {\n        return null;\n      }\n\n      return results[0];\n    };\n  }\n\n  function getByQuery(instance: ReactTestInstance) {\n    return function getFn(predicate: Predicate, options?: Options) {\n      const results = queryAllByQuery(instance)(predicate, options);\n\n      if (results.length > 1) {\n        throw new ErrorWithStack(getMultipleError(predicate), getFn);\n      }\n\n      if (results.length === 0) {\n        throw new ErrorWithStack(getMissingError(predicate), getFn);\n      }\n\n      return results[0];\n    };\n  }\n\n  function findAllByQuery(instance: ReactTestInstance) {\n    return function findAllFn(\n      predicate: Predicate,\n      queryOptions?: Options & WaitForOptions,\n      waitForOptions: WaitForOptions = {}\n    ) {\n      const deprecatedWaitForOptions = extractDeprecatedWaitForOptionUsage(\n        queryOptions\n      );\n      return waitFor(() => getAllByQuery(instance)(predicate, queryOptions), {\n        ...deprecatedWaitForOptions,\n        ...waitForOptions,\n      });\n    };\n  }\n\n  function findByQuery(instance: ReactTestInstance) {\n    return function findFn(\n      predicate: Predicate,\n      queryOptions?: Options & WaitForOptions,\n      waitForOptions: WaitForOptions = {}\n    ) {\n      const deprecatedWaitForOptions = extractDeprecatedWaitForOptionUsage(\n        queryOptions\n      );\n      return waitFor(() => getByQuery(instance)(predicate, queryOptions), {\n        ...deprecatedWaitForOptions,\n        ...waitForOptions,\n      });\n    };\n  }\n\n  return {\n    getBy: getByQuery,\n    getAllBy: getAllByQuery,\n    queryBy: queryByQuery,\n    queryAllBy: queryAllByQuery,\n    findBy: findByQuery,\n    findAllBy: findAllByQuery,\n  };\n}\n"],"file":"makeQueries.js"}

package/build/queries/placeholderText.d.ts

@@ -0,0 +1,13 @@
+import type { ReactTestInstance } from 'react-test-renderer';
+import { TextMatch } from '../matches';
+import type { FindAllByQuery, FindByQuery, GetAllByQuery, GetByQuery, QueryAllByQuery, QueryByQuery } from './makeQueries';
+import type { TextMatchOptions } from './text';
+export declare type ByPlaceholderTextQueries = {
+    getByPlaceholderText: GetByQuery<TextMatch, TextMatchOptions>;
+    getAllByPlaceholderText: GetAllByQuery<TextMatch, TextMatchOptions>;
+    queryByPlaceholderText: QueryByQuery<TextMatch, TextMatchOptions>;
+    queryAllByPlaceholderText: QueryAllByQuery<TextMatch, TextMatchOptions>;
+    findByPlaceholderText: FindByQuery<TextMatch, TextMatchOptions>;
+    findAllByPlaceholderText: FindAllByQuery<TextMatch, TextMatchOptions>;
+};
+export declare const bindByPlaceholderTextQueries: (instance: ReactTestInstance) => ByPlaceholderTextQueries;

package/build/{helpers/byPlaceholderText.js → queries/placeholderText.js}

@@ -3,15 +3,15 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.queryByPlaceholderText = exports.queryAllByPlaceholderText = exports.getByPlaceholderText = exports.getAllByPlaceholderText = exports.findByPlaceholderText = exports.findAllByPlaceholderText = void 0;
+exports.bindByPlaceholderTextQueries = void 0;
 
-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");
 
 const getTextInputNodeByPlaceholderText = (node, placeholder, options = {}) => {
   try {
@@ -33,22 +33,27 @@ const queryAllByPlaceholderText = instance => function queryAllByPlaceholderFn(p
   return instance.findAll(node => getTextInputNodeByPlaceholderText(node, placeholder, queryOptions));
 };
 
-exports.queryAllByPlaceholderText = queryAllByPlaceholderText;
-
 const getMultipleError = placeholder => `Found multiple elements with placeholder: ${String(placeholder)} `;
 
 const getMissingError = placeholder => `Unable to find an element with placeholder: ${String(placeholder)}`;
 
 const {
-  getBy: getByPlaceholderText,
-  getAllBy: getAllByPlaceholderText,
-  queryBy: queryByPlaceholderText,
-  findBy: findByPlaceholderText,
-  findAllBy: findAllByPlaceholderText
+  getBy,
+  getAllBy,
+  queryBy,
+  queryAllBy,
+  findBy,
+  findAllBy
 } = (0, _makeQueries.makeQueries)(queryAllByPlaceholderText, getMissingError, getMultipleError);
-exports.findAllByPlaceholderText = findAllByPlaceholderText;
-exports.findByPlaceholderText = findByPlaceholderText;
-exports.queryByPlaceholderText = queryByPlaceholderText;
-exports.getAllByPlaceholderText = getAllByPlaceholderText;
-exports.getByPlaceholderText = getByPlaceholderText;
-//# sourceMappingURL=byPlaceholderText.js.map
+
+const bindByPlaceholderTextQueries = instance => ({
+  getByPlaceholderText: getBy(instance),
+  getAllByPlaceholderText: getAllBy(instance),
+  queryByPlaceholderText: queryBy(instance),
+  queryAllByPlaceholderText: queryAllBy(instance),
+  findByPlaceholderText: findBy(instance),
+  findAllByPlaceholderText: findAllBy(instance)
+});
+
+exports.bindByPlaceholderTextQueries = bindByPlaceholderTextQueries;
+//# sourceMappingURL=placeholderText.js.map

package/build/queries/placeholderText.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/queries/placeholderText.ts"],"names":["getTextInputNodeByPlaceholderText","node","placeholder","options","TextInput","require","exact","normalizer","props","error","queryAllByPlaceholderText","instance","queryAllByPlaceholderFn","queryOptions","findAll","getMultipleError","String","getMissingError","getBy","getAllBy","queryBy","queryAllBy","findBy","findAllBy","bindByPlaceholderTextQueries","getByPlaceholderText","getAllByPlaceholderText","queryByPlaceholderText","findByPlaceholderText","findAllByPlaceholderText"],"mappings":";;;;;;;AACA;;AACA;;AACA;;AACA;;AAWA,MAAMA,iCAAiC,GAAG,CACxCC,IADwC,EAExCC,WAFwC,EAGxCC,OAAyB,GAAG,EAHY,KAIrC;AACH,MAAI;AACF,UAAM;AAAEC,MAAAA;AAAF,QAAgBC,OAAO,CAAC,cAAD,CAA7B;;AACA,UAAM;AAAEC,MAAAA,KAAF;AAASC,MAAAA;AAAT,QAAwBJ,OAA9B;AACA,WACE,wCAAiBF,IAAjB,EAAuBG,SAAvB,KACA,sBAAQF,WAAR,EAAqBD,IAAI,CAACO,KAAL,CAAWN,WAAhC,EAA6CK,UAA7C,EAAyDD,KAAzD,CAFF;AAID,GAPD,CAOE,OAAOG,KAAP,EAAc;AACd,UAAM,4CAA+BA,KAA/B,CAAN;AACD;AACF,CAfD;;AAiBA,MAAMC,yBAAyB,GAC7BC,QADgC,IAMhC,SAASC,uBAAT,CAAiCV,WAAjC,EAA8CW,YAA9C,EAA4D;AAC1D,SAAOF,QAAQ,CAACG,OAAT,CAAkBb,IAAD,IACtBD,iCAAiC,CAACC,IAAD,EAAOC,WAAP,EAAoBW,YAApB,CAD5B,CAAP;AAGD,CAVH;;AAYA,MAAME,gBAAgB,GAAIb,WAAD,IACtB,6CAA4Cc,MAAM,CAACd,WAAD,CAAc,GADnE;;AAEA,MAAMe,eAAe,GAAIf,WAAD,IACrB,+CAA8Cc,MAAM,CAACd,WAAD,CAAc,EADrE;;AAGA,MAAM;AAAEgB,EAAAA,KAAF;AAASC,EAAAA,QAAT;AAAmBC,EAAAA,OAAnB;AAA4BC,EAAAA,UAA5B;AAAwCC,EAAAA,MAAxC;AAAgDC,EAAAA;AAAhD,IAA8D,8BAClEb,yBADkE,EAElEO,eAFkE,EAGlEF,gBAHkE,CAApE;;AAeO,MAAMS,4BAA4B,GACvCb,QAD0C,KAEZ;AAC9Bc,EAAAA,oBAAoB,EAAEP,KAAK,CAACP,QAAD,CADG;AAE9Be,EAAAA,uBAAuB,EAAEP,QAAQ,CAACR,QAAD,CAFH;AAG9BgB,EAAAA,sBAAsB,EAAEP,OAAO,CAACT,QAAD,CAHD;AAI9BD,EAAAA,yBAAyB,EAAEW,UAAU,CAACV,QAAD,CAJP;AAK9BiB,EAAAA,qBAAqB,EAAEN,MAAM,CAACX,QAAD,CALC;AAM9BkB,EAAAA,wBAAwB,EAAEN,SAAS,CAACZ,QAAD;AANL,CAFY,CAArC","sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport { createLibraryNotSupportedError } from '../helpers/errors';\nimport { filterNodeByType } from '../helpers/filterNodeByType';\nimport { matches, TextMatch } from '../matches';\nimport { makeQueries } from './makeQueries';\nimport type {\n  FindAllByQuery,\n  FindByQuery,\n  GetAllByQuery,\n  GetByQuery,\n  QueryAllByQuery,\n  QueryByQuery,\n} from './makeQueries';\nimport type { TextMatchOptions } from './text';\n\nconst getTextInputNodeByPlaceholderText = (\n  node: ReactTestInstance,\n  placeholder: TextMatch,\n  options: TextMatchOptions = {}\n) => {\n  try {\n    const { TextInput } = require('react-native');\n    const { exact, normalizer } = options;\n    return (\n      filterNodeByType(node, TextInput) &&\n      matches(placeholder, node.props.placeholder, normalizer, exact)\n    );\n  } catch (error) {\n    throw createLibraryNotSupportedError(error);\n  }\n};\n\nconst queryAllByPlaceholderText = (\n  instance: ReactTestInstance\n): ((\n  placeholder: TextMatch,\n  queryOptions?: TextMatchOptions\n) => Array<ReactTestInstance>) =>\n  function queryAllByPlaceholderFn(placeholder, queryOptions) {\n    return instance.findAll((node) =>\n      getTextInputNodeByPlaceholderText(node, placeholder, queryOptions)\n    );\n  };\n\nconst getMultipleError = (placeholder: TextMatch) =>\n  `Found multiple elements with placeholder: ${String(placeholder)} `;\nconst getMissingError = (placeholder: TextMatch) =>\n  `Unable to find an element with placeholder: ${String(placeholder)}`;\n\nconst { getBy, getAllBy, queryBy, queryAllBy, findBy, findAllBy } = makeQueries(\n  queryAllByPlaceholderText,\n  getMissingError,\n  getMultipleError\n);\n\nexport type ByPlaceholderTextQueries = {\n  getByPlaceholderText: GetByQuery<TextMatch, TextMatchOptions>;\n  getAllByPlaceholderText: GetAllByQuery<TextMatch, TextMatchOptions>;\n  queryByPlaceholderText: QueryByQuery<TextMatch, TextMatchOptions>;\n  queryAllByPlaceholderText: QueryAllByQuery<TextMatch, TextMatchOptions>;\n  findByPlaceholderText: FindByQuery<TextMatch, TextMatchOptions>;\n  findAllByPlaceholderText: FindAllByQuery<TextMatch, TextMatchOptions>;\n};\n\nexport const bindByPlaceholderTextQueries = (\n  instance: ReactTestInstance\n): ByPlaceholderTextQueries => ({\n  getByPlaceholderText: getBy(instance),\n  getAllByPlaceholderText: getAllBy(instance),\n  queryByPlaceholderText: queryBy(instance),\n  queryAllByPlaceholderText: queryAllBy(instance),\n  findByPlaceholderText: findBy(instance),\n  findAllByPlaceholderText: findAllBy(instance),\n});\n"],"file":"placeholderText.js"}

package/build/queries/testId.d.ts

@@ -0,0 +1,13 @@
+import type { ReactTestInstance } from 'react-test-renderer';
+import { TextMatch } from '../matches';
+import type { FindAllByQuery, FindByQuery, GetAllByQuery, GetByQuery, QueryAllByQuery, QueryByQuery } from './makeQueries';
+import type { TextMatchOptions } from './text';
+export declare type ByTestIdQueries = {
+    getByTestId: GetByQuery<TextMatch, TextMatchOptions>;
+    getAllByTestId: GetAllByQuery<TextMatch, TextMatchOptions>;
+    queryByTestId: QueryByQuery<TextMatch, TextMatchOptions>;
+    queryAllByTestId: QueryAllByQuery<TextMatch, TextMatchOptions>;
+    findByTestId: FindByQuery<TextMatch, TextMatchOptions>;
+    findAllByTestId: FindAllByQuery<TextMatch, TextMatchOptions>;
+};
+export declare const bindByTestIdQueries: (instance: ReactTestInstance) => ByTestIdQueries;

package/build/{helpers/byTestId.js → queries/testId.js}

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.queryByTestId = exports.queryAllByTestId = exports.getByTestId = exports.getAllByTestId = exports.findByTestId = exports.findAllByTestId = void 0;
+exports.bindByTestIdQueries = void 0;
 
 var _matches = require("../matches");
 
@@ -22,22 +22,27 @@ const queryAllByTestId = instance => function queryAllByTestIdFn(testId, queryOp
   return results;
 };
 
-exports.queryAllByTestId = queryAllByTestId;
-
 const getMultipleError = testId => `Found multiple elements with testID: ${String(testId)}`;
 
 const getMissingError = testId => `Unable to find an element with testID: ${String(testId)}`;
 
 const {
-  getBy: getByTestId,
-  getAllBy: getAllByTestId,
-  queryBy: queryByTestId,
-  findBy: findByTestId,
-  findAllBy: findAllByTestId
+  getBy,
+  getAllBy,
+  queryBy,
+  queryAllBy,
+  findBy,
+  findAllBy
 } = (0, _makeQueries.makeQueries)(queryAllByTestId, getMissingError, getMultipleError);
-exports.findAllByTestId = findAllByTestId;
-exports.findByTestId = findByTestId;
-exports.queryByTestId = queryByTestId;
-exports.getAllByTestId = getAllByTestId;
-exports.getByTestId = getByTestId;
-//# sourceMappingURL=byTestId.js.map
+
+const bindByTestIdQueries = instance => ({
+  getByTestId: getBy(instance),
+  getAllByTestId: getAllBy(instance),
+  queryByTestId: queryBy(instance),
+  queryAllByTestId: queryAllBy(instance),
+  findByTestId: findBy(instance),
+  findAllByTestId: findAllBy(instance)
+});
+
+exports.bindByTestIdQueries = bindByTestIdQueries;
+//# sourceMappingURL=testId.js.map

package/build/queries/testId.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/queries/testId.ts"],"names":["getNodeByTestId","node","testID","options","exact","normalizer","props","queryAllByTestId","instance","queryAllByTestIdFn","testId","queryOptions","results","findAll","filter","element","type","getMultipleError","String","getMissingError","getBy","getAllBy","queryBy","queryAllBy","findBy","findAllBy","bindByTestIdQueries","getByTestId","getAllByTestId","queryByTestId","findByTestId","findAllByTestId"],"mappings":";;;;;;;AACA;;AACA;;AAWA,MAAMA,eAAe,GAAG,CACtBC,IADsB,EAEtBC,MAFsB,EAGtBC,OAAyB,GAAG,EAHN,KAInB;AACH,QAAM;AAAEC,IAAAA,KAAF;AAASC,IAAAA;AAAT,MAAwBF,OAA9B;AACA,SAAO,sBAAQD,MAAR,EAAgBD,IAAI,CAACK,KAAL,CAAWJ,MAA3B,EAAmCG,UAAnC,EAA+CD,KAA/C,CAAP;AACD,CAPD;;AASA,MAAMG,gBAAgB,GACpBC,QADuB,IAMvB,SAASC,kBAAT,CAA4BC,MAA5B,EAAoCC,YAApC,EAAkD;AAChD,QAAMC,OAAO,GAAGJ,QAAQ,CACrBK,OADa,CACJZ,IAAD,IAAUD,eAAe,CAACC,IAAD,EAAOS,MAAP,EAAeC,YAAf,CADpB,EAEbG,MAFa,CAELC,OAAD,IAAa,OAAOA,OAAO,CAACC,IAAf,KAAwB,QAF/B,CAAhB;AAIA,SAAOJ,OAAP;AACD,CAZH;;AAcA,MAAMK,gBAAgB,GAAIP,MAAD,IACtB,wCAAuCQ,MAAM,CAACR,MAAD,CAAS,EADzD;;AAEA,MAAMS,eAAe,GAAIT,MAAD,IACrB,0CAAyCQ,MAAM,CAACR,MAAD,CAAS,EAD3D;;AAGA,MAAM;AAAEU,EAAAA,KAAF;AAASC,EAAAA,QAAT;AAAmBC,EAAAA,OAAnB;AAA4BC,EAAAA,UAA5B;AAAwCC,EAAAA,MAAxC;AAAgDC,EAAAA;AAAhD,IAA8D,8BAClElB,gBADkE,EAElEY,eAFkE,EAGlEF,gBAHkE,CAApE;;AAeO,MAAMS,mBAAmB,GAC9BlB,QADiC,KAEZ;AACrBmB,EAAAA,WAAW,EAAEP,KAAK,CAACZ,QAAD,CADG;AAErBoB,EAAAA,cAAc,EAAEP,QAAQ,CAACb,QAAD,CAFH;AAGrBqB,EAAAA,aAAa,EAAEP,OAAO,CAACd,QAAD,CAHD;AAIrBD,EAAAA,gBAAgB,EAAEgB,UAAU,CAACf,QAAD,CAJP;AAKrBsB,EAAAA,YAAY,EAAEN,MAAM,CAAChB,QAAD,CALC;AAMrBuB,EAAAA,eAAe,EAAEN,SAAS,CAACjB,QAAD;AANL,CAFY,CAA5B","sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport { matches, TextMatch } from '../matches';\nimport { makeQueries } from './makeQueries';\nimport type {\n  FindAllByQuery,\n  FindByQuery,\n  GetAllByQuery,\n  GetByQuery,\n  QueryAllByQuery,\n  QueryByQuery,\n} from './makeQueries';\nimport type { TextMatchOptions } from './text';\n\nconst getNodeByTestId = (\n  node: ReactTestInstance,\n  testID: TextMatch,\n  options: TextMatchOptions = {}\n) => {\n  const { exact, normalizer } = options;\n  return matches(testID, node.props.testID, normalizer, exact);\n};\n\nconst queryAllByTestId = (\n  instance: ReactTestInstance\n): ((\n  testId: TextMatch,\n  queryOptions?: TextMatchOptions\n) => Array<ReactTestInstance>) =>\n  function queryAllByTestIdFn(testId, queryOptions) {\n    const results = instance\n      .findAll((node) => getNodeByTestId(node, testId, queryOptions))\n      .filter((element) => typeof element.type === 'string');\n\n    return results;\n  };\n\nconst getMultipleError = (testId: TextMatch) =>\n  `Found multiple elements with testID: ${String(testId)}`;\nconst getMissingError = (testId: TextMatch) =>\n  `Unable to find an element with testID: ${String(testId)}`;\n\nconst { getBy, getAllBy, queryBy, queryAllBy, findBy, findAllBy } = makeQueries(\n  queryAllByTestId,\n  getMissingError,\n  getMultipleError\n);\n\nexport type ByTestIdQueries = {\n  getByTestId: GetByQuery<TextMatch, TextMatchOptions>;\n  getAllByTestId: GetAllByQuery<TextMatch, TextMatchOptions>;\n  queryByTestId: QueryByQuery<TextMatch, TextMatchOptions>;\n  queryAllByTestId: QueryAllByQuery<TextMatch, TextMatchOptions>;\n  findByTestId: FindByQuery<TextMatch, TextMatchOptions>;\n  findAllByTestId: FindAllByQuery<TextMatch, TextMatchOptions>;\n};\n\nexport const bindByTestIdQueries = (\n  instance: ReactTestInstance\n): ByTestIdQueries => ({\n  getByTestId: getBy(instance),\n  getAllByTestId: getAllBy(instance),\n  queryByTestId: queryBy(instance),\n  queryAllByTestId: queryAllBy(instance),\n  findByTestId: findBy(instance),\n  findAllByTestId: findAllBy(instance),\n});\n"],"file":"testId.js"}

package/build/queries/text.d.ts

@@ -0,0 +1,17 @@
+import type { ReactTestInstance } from 'react-test-renderer';
+import { TextMatch } from '../matches';
+import type { NormalizerFn } from '../matches';
+import type { FindAllByQuery, FindByQuery, GetAllByQuery, GetByQuery, QueryAllByQuery, QueryByQuery } from './makeQueries';
+export declare type TextMatchOptions = {
+    exact?: boolean;
+    normalizer?: NormalizerFn;
+};
+export declare type ByTextQueries = {
+    getByText: GetByQuery<TextMatch, TextMatchOptions>;
+    getAllByText: GetAllByQuery<TextMatch, TextMatchOptions>;
+    queryByText: QueryByQuery<TextMatch, TextMatchOptions>;
+    queryAllByText: QueryAllByQuery<TextMatch, TextMatchOptions>;
+    findByText: FindByQuery<TextMatch, TextMatchOptions>;
+    findAllByText: FindAllByQuery<TextMatch, TextMatchOptions>;
+};
+export declare const bindByTextQueries: (instance: ReactTestInstance) => ByTextQueries;

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

@@ -3,17 +3,17 @@
 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(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
@@ -78,27 +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;
-//# sourceMappingURL=byText.js.map
+
+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"}