├── .eslintignore
├── .eslintrc.json
├── .gitignore
├── README.md
├── images
    └── sample-transform.png
├── package.json
├── src
    ├── format.ts
    ├── transform.ts
    └── transforms
    │   ├── __testfixtures__
    │       ├── jest-no-manual-cleanup
    │       │   ├── cleanup-as-argument.input.ts
    │       │   ├── keep-lifecycle-method.input.ts
    │       │   ├── remove-cleanup-call.input.ts
    │       │   └── remove-lifecycle-method.input.ts
    │       ├── jest-prefer-presence-queries
    │       │   ├── falsy-queries.input.tsx
    │       │   └── truthy-queries.input.tsx
    │       └── jest-prefer-screen-queries
    │       │   ├── destructure-and-unused-global-var.input.tsx
    │       │   ├── destructure-and-unused-local-var.input.tsx
    │       │   ├── empty-destructure.input.tsx
    │       │   ├── insert-import-after-react.input.tsx
    │       │   ├── keep-object-props.input.tsx
    │       │   ├── keep-other-imports.input.tsx
    │       │   ├── keep-query-options.input.tsx
    │       │   ├── keep-referenced-vars.input.tsx
    │       │   ├── named-destructure.input.tsx
    │       │   ├── named-imports.input.tsx
    │       │   ├── non-empty-destructure.input.tsx
    │       │   ├── query-within.input.tsx
    │       │   ├── replace-member-expressions.input.tsx
    │       │   ├── respect-shadowed-vars.input.tsx
    │       │   ├── reuse-existing-import.input.tsx
    │       │   └── screen-and-within.input.tsx
    │   ├── __tests__
    │       ├── __snapshots__
    │       │   ├── jest-no-manual-cleanup.test.ts.snap
    │       │   ├── jest-prefer-presence-queries.test.ts.snap
    │       │   └── jest-prefer-screen-queries.test.ts.snap
    │       ├── jest-no-manual-cleanup.test.ts
    │       ├── jest-prefer-presence-queries.test.ts
    │       └── jest-prefer-screen-queries.test.ts
    │   ├── no-manual-cleanup.ts
    │   ├── prefer-presence-queries.ts
    │   ├── prefer-screen-queries.ts
    │   └── utils
    │       ├── index.ts
    │       └── testUtils.ts
├── tsconfig.json
└── yarn.lock


/.eslintignore:
--------------------------------------------------------------------------------
1 | /.history/
2 | /node_modules/
3 | **/__testfixtures__/*
4 | /samples/


--------------------------------------------------------------------------------
/.eslintrc.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "root": true,
 3 |   "parser": "@typescript-eslint/parser",
 4 |   "plugins": [
 5 |     "@typescript-eslint"
 6 |   ],
 7 |   "extends": [
 8 |     "eslint:recommended",
 9 |     "plugin:@typescript-eslint/recommended"
10 |   ],
11 |   "rules": {
12 |     "quotes": [
13 |       "error",
14 |       "single",
15 |       {
16 |         "avoidEscape": true
17 |       }
18 |     ],
19 |     "semi": ["error", "never"],
20 |     "max-len": ["error", 100],
21 |     "no-trailing-spaces": "error",
22 |     "comma-dangle": [
23 |       "error",
24 |       {
25 |         "arrays": "always-multiline",
26 |         "objects": "always-multiline",
27 |         "imports": "always-multiline",
28 |         "exports": "always-multiline",
29 |         "functions": "always-multiline"
30 |       }
31 |     ],
32 |     "comma-spacing": "error",
33 |     "object-curly-spacing": [
34 |       "error",
35 |       "always",
36 |       {
37 |         "objectsInObjects": true,
38 |         "arraysInObjects": true
39 |       }
40 |     ],
41 |     "array-bracket-spacing": ["error", "never"],
42 |     "curly": ["error", "all"],
43 |     "func-call-spacing": ["error", "never"],
44 |     "no-lonely-if": "error",
45 |     "prefer-const": "error",
46 |     "prefer-arrow-callback": "error",
47 |     "no-shadow": "error",
48 |     "indent": ["error", 2],
49 |     "no-console": "warn"
50 |   }
51 | }
52 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /node_modules/
2 | .vscode
3 | .history
4 | .DS_Store
5 | /samples/
6 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # eslint-jest-testing-library-codemod
  2 | 
  3 | **eslint-jest-testing-library-codemod** provides a set of autofixes to make migration to [eslint-plugin-testing-library](https://github.com/testing-library/eslint-plugin-testing-library) ruleset less painful. Codemod is based on [jscodeshift](https://github.com/facebook/jscodeshift).
  4 | 
  5 | ## Usage
  6 | ```
  7 | yarn transform --fix=<fixer name> --<option>=<value> <path to folder>
  8 | ```
  9 | Fixer name is a module name from `src/transforms/`. Fixers could be provided as a comma-separated list or multiple `--fix` arguments.
 10 | 
 11 | Available fixers in recommended order:
 12 | ```
 13 | prefer-screen-queries
 14 | options:
 15 |   memberExpressions: true
 16 | 
 17 | prefer-presence-queries
 18 | 
 19 | no-manual-cleanup
 20 | ```
 21 | 
 22 | Codemod will pick all js, jsx, ts, tsx files, ignoring `node_modules`. [jscodeshift](https://github.com/facebook/jscodeshift) params could be passed as well.
 23 | 
 24 | 
 25 | ## Example
 26 | 
 27 | ```
 28 | yarn transform --fix=prefer-screen-queries,prefer-presence-queries,no-manual-cleanup ./src
 29 | ```
 30 | 
 31 | Looks cool, right?
 32 | 
 33 | ![Sample transform diff](https://github.com/atsikov/eslint-jest-testing-library-codemod/blob/master/images/sample-transform.png)
 34 | 
 35 | ## Fixers
 36 | 
 37 | ### prefer-screen-queries
 38 | 
 39 | Fixes `testing-library/prefer-screen-queries` rule.
 40 | 
 41 | Fixer is capable to fix various scenarios. `screen` import will be added if necessary.
 42 | 
 43 | * Replace query taken from `render()` result
 44 | ```
 45 | const { getByText } = render(<div />)
 46 | expect(getByText('text')).not.toBeNull()
 47 | ```
 48 | is transformed to
 49 | ```
 50 | render(<div />)
 51 | expect(screen.getByText('text')).not.toBeNull()
 52 | ```
 53 | 
 54 | * Replace query taken from `render()` result, which was assigned to var
 55 | ```
 56 | const rendered = render(<div />)
 57 | const { getByText } = rendered
 58 | expect(getByText('text')).not.toBeNull()
 59 | ```
 60 | is transformed to
 61 | ```
 62 | render(<div />)
 63 | expect(screen.getByText('text')).not.toBeNull()
 64 | ```
 65 | 
 66 | * Handle globally imported queries
 67 | ```
 68 | import { getByText as gBT, screen } from '@testing-library/react'
 69 | render(<div />)
 70 | const child = screen.getByText('child')
 71 | expect(gBT(child, 'text')).not.toBeNull()
 72 | ```
 73 | is transformed to
 74 | ```
 75 | import { screen, within } from '@testing-library/react'
 76 | render(<div />)
 77 | const child = screen.getByText('child')
 78 | expect(within(child).getByText('text')).not.toBeNull()
 79 | ```
 80 | 
 81 | * Replace query taken from variable where `render()` result was assigned, removing this var when it is not referenced (with `memberExpression: true` option)
 82 | ```
 83 | const rendered = render(<div />)
 84 | expect(rendered.getByText('text')).not.toBeNull()
 85 | ```
 86 | is transformed to
 87 | ```
 88 | render(<div />)
 89 | expect(screen.getByText('text')).not.toBeNull()
 90 | ```
 91 | Handles variables from upper scope
 92 | ```
 93 | let rendered
 94 | it('test', () => {
 95 |   rendered = render(<div />)
 96 |   expect(rendered.getByText('text')).not.toBeNull()
 97 | })
 98 | ```
 99 | is transformed to
100 | ```
101 | it('test', () => {
102 |   render(<div />) 
103 |   expect(screen.getByText('text')).not.toBeNull()
104 | })
105 | ```
106 | Unused type will also be removed
107 | ```
108 | import { RenderResult } from '@testing-library/react'
109 | let rendered
110 | rendered = render(<div />)
111 | expect(rendered.getByText('text')).not.toBeNull()
112 | ```
113 | is transformed to
114 | ```
115 | import { screen } from '@testing-library/react'
116 | render(<div />)
117 | expect(screen.getByText('text')).not.toBeNull()
118 | ```
119 | 
120 | ### no-manual-cleanup
121 | 
122 | Fixes `testing-library/no-manual-cleanup` rule.
123 | 
124 | * Removes `cleanup` calls
125 | ```
126 | import { cleanup } from '@testing-library/react'
127 | 
128 | it('test', () => {
129 |   cleanup()
130 |   render(<div />)
131 | })
132 | ```
133 | is transformed to 
134 | ```
135 | it('test', () => {
136 |   render(<div />)
137 | })
138 | ```
139 | 
140 | * Removes jest lifecycle methods in case `cleanup` was the only call
141 | ```
142 | import { cleanup, render } from '@testing-library/react'
143 | 
144 | afterEach(() => {
145 |   cleanup()
146 | })
147 | 
148 | test('test', () => {
149 |   render()
150 | })
151 | ```
152 | is transformed to 
153 | ```
154 | import { render } from '@testing-library/react'
155 | 
156 | it('test', () => {
157 |   render(<div />)
158 | })
159 | ```
160 | 
161 | * Handles case when `cleanup` is passed to jest lifecycle method as a callback
162 | ```
163 | import { cleanup, render } from '@testing-library/react'
164 | 
165 | afterEach(cleanup)
166 | 
167 | test('test', () => {
168 |   render()
169 | })
170 | ```
171 | is transformed to 
172 | ```
173 | import { render } from '@testing-library/react'
174 | 
175 | it('test', () => {
176 |   render(<div />)
177 | })
178 | ```
179 | 
180 | ### prefer-presence-queries
181 | 
182 | Fixes `testing-library/prefer-presence-queries` rule.
183 | 
184 | * Replace truthy assertions with `getBy*` queries
185 | * Replace falsy assertions with `queryBy*` queries
186 | 


--------------------------------------------------------------------------------
/images/sample-transform.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/atsikov/eslint-jest-testing-library-codemod/d0551272e7273f61474505bff0efe448789ffdd5/images/sample-transform.png


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "eslint-jest-testing-library-codemod",
 3 |   "version": "0.0.1",
 4 |   "license": "MIT",
 5 |   "scripts": {
 6 |     "test": "jest",
 7 |     "transform": "jscodeshift --parser=tsx -t=./src/transform.ts --extensions=js,jsx,ts,tsx --ignore-pattern='../**/node_modules/**' --ignore-pattern='**/node_modules/**'"
 8 |   },
 9 |   "devDependencies": {
10 |     "@types/jest": "^26.0.8",
11 |     "@types/jscodeshift": "^0.7.1",
12 |     "@types/node": "^14.0.27",
13 |     "@types/prettier": "^2.0.2",
14 |     "@typescript-eslint/eslint-plugin": "^3.7.1",
15 |     "@typescript-eslint/parser": "^3.7.1",
16 |     "eslint": "^7.6.0",
17 |     "jest": "^26.2.2",
18 |     "jscodeshift": "^0.10.0",
19 |     "prettier": "^2.0.5",
20 |     "ts-jest": "^26.1.4",
21 |     "typescript": "^3.9.7"
22 |   },
23 |   "jest": {
24 |     "preset": "ts-jest",
25 |     "testEnvironment": "node",
26 |     "rootDir": "src"
27 |   }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/format.ts:
--------------------------------------------------------------------------------
 1 | import prettier from 'prettier'
 2 | 
 3 | function format(source: string): string {
 4 |   return prettier.format(source, {
 5 |     parser: 'typescript',
 6 |     singleQuote: true,
 7 |     semi: false,
 8 |     trailingComma: 'all',
 9 |     printWidth: 90,
10 |     arrowParens: 'avoid',
11 |   })
12 | }
13 | 
14 | export default format
15 | 


--------------------------------------------------------------------------------
/src/transform.ts:
--------------------------------------------------------------------------------
 1 | import { Transform } from 'jscodeshift'
 2 | 
 3 | import format from './format'
 4 | 
 5 | const transform: Transform = (fileInfo, api, options) => {
 6 |   const fixers = options.fix
 7 |   if (!fixers) {
 8 |     // eslint-disable-next-line no-console
 9 |     console.error('Fixers list should be provided with --fix argument')
10 |     process.exit(1)
11 |   }
12 | 
13 |   const fixersList: string[] = typeof fixers === 'object' && 'length' in fixers
14 |     ? fixers
15 |     : fixers.split(',')
16 | 
17 |   const transforms = fixersList.map(
18 |     // eslint-disable-next-line @typescript-eslint/no-var-requires
19 |     fixerName => require(`./transforms/${fixerName.trim()}`).default,
20 |   )
21 | 
22 |   const transformedSource = transforms.reduce((source: string, t) => {
23 |     return t({ ...fileInfo, source }, api, options) || ''
24 |   }, fileInfo.source)
25 | 
26 |   return format(transformedSource)
27 | }
28 | 
29 | export const parser = 'tsx'
30 | export default transform
31 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-no-manual-cleanup/cleanup-as-argument.input.ts:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | import { cleanup, screen } from '@testing-library/react'
3 | 
4 | afterEach(cleanup)
5 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-no-manual-cleanup/keep-lifecycle-method.input.ts:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | import { cleanup, render, screen } from '@testing-library/react'
3 | 
4 | afterEach(() => {
5 |   foo()
6 |   cleanup()
7 | })
8 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-no-manual-cleanup/remove-cleanup-call.input.ts:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | import { cleanup, render, screen } from '@testing-library/react'
3 | 
4 | it('test', () => {
5 |   cleanup()
6 | })
7 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-no-manual-cleanup/remove-lifecycle-method.input.ts:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | import { cleanup, render, screen } from '@testing-library/react'
3 | 
4 | afterEach(() => {
5 |   cleanup()
6 | })
7 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-presence-queries/falsy-queries.input.tsx:
--------------------------------------------------------------------------------
 1 | // @ts-nocheck
 2 | it('test', () => {
 3 |   expect(getByTestId('id')).toBeNull()
 4 |   expect(getByText('id')).toBeFalsy()
 5 |   expect(getByRole('id')).not.toBeInTheDocument()
 6 |   expect(getByLabelText('id')).not.toBeDefined()
 7 |   expect(screen.getByTestId('id')).toBeNull()
 8 |   expect(screen.getByText('id')).toBeFalsy()
 9 |   expect(screen.getByRole('id')).not.toBeInTheDocument()
10 |   expect(screen.getByLabelText('id')).not.toBeDefined()
11 |   expect(a.b.getByTestId('id')).toBeNull()
12 |   expect(a.b.getByText('id')).toBeFalsy()
13 |   expect(a.b.getByRole('id')).not.toBeInTheDocument()
14 |   expect(a.b.getByLabelText('id')).not.toBeDefined()
15 | })
16 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-presence-queries/truthy-queries.input.tsx:
--------------------------------------------------------------------------------
 1 | // @ts-nocheck
 2 | it('test', () => {
 3 |   expect(queryByTestId('id')).not.toBeNull()
 4 |   expect(queryByText('id')).toBeTruthy()
 5 |   expect(queryByRole('id')).toBeInTheDocument()
 6 |   expect(queryByLabelText('id')).toBeDefined()
 7 |   expect(screen.queryByTestId('id')).not.toBeNull()
 8 |   expect(screen.queryByText('id')).toBeTruthy()
 9 |   expect(screen.queryByRole('id')).toBeInTheDocument()
10 |   expect(screen.queryByLabelText('id')).toBeDefined()
11 |   expect(a.b.queryByTestId('id')).not.toBeNull()
12 |   expect(a.b.queryByText('id')).toBeTruthy()
13 |   expect(a.b.queryByRole('id')).toBeInTheDocument()
14 |   expect(a.b.queryByLabelText('id')).toBeDefined()
15 | })
16 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/destructure-and-unused-global-var.input.tsx:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | let rendered: any
3 | 
4 | it('test', () => {
5 |   rendered = render(<A />)
6 |   const { getByText } = rendered
7 |   expect(getByText('text')).toBeInTheDocument()
8 | })
9 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/destructure-and-unused-local-var.input.tsx:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | it('test', () => {
3 |   const rendered = render(<A />)
4 |   const { getByText } = rendered
5 |   expect(getByText('text')).toBeInTheDocument()
6 | })
7 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/empty-destructure.input.tsx:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | it('test', () => {
3 |   const { getByTestId } = render({ foo: true })
4 | 
5 |   expect(getByTestId('foo')).toBeInTheDocument()
6 | })
7 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/insert-import-after-react.input.tsx:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | import React from 'react'
3 | 
4 | it('test', () => {
5 |   const { getByText } = render(<A />)
6 |   expect(getByText('text')).toBeInTheDocument()
7 | })
8 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/keep-object-props.input.tsx:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | import React from 'react'
3 | 
4 | it('test', () => {
5 |   expect(obj.getByText('textA')).not.toBeNull()
6 | })
7 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/keep-other-imports.input.tsx:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | import { getByText, screen, within } from '@testing-library/react'
3 | 
4 | it('test', () => {
5 |   const { getByText } = render(<A />)
6 |   expect(getByText('text')).toBeInTheDocument()
7 | })
8 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/keep-query-options.input.tsx:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | import React from 'react'
3 | 
4 | it('test', () => {
5 |   const { getByText } = render(<A />)
6 |   expect(getByText(container, options)).toBeInTheDocument()
7 |   expect(getByText(container, undefined, options)).toBeInTheDocument()
8 | })
9 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/keep-referenced-vars.input.tsx:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | import React from 'react'
3 | 
4 | it('test', () => {
5 |   const rendered = render(<A />)
6 |   expect(rendered.getByText('text')).toBeInTheDocument()
7 |   rendered.foo
8 | })
9 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/named-destructure.input.tsx:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | it('test', () => {
3 |   const { getByText: gbt } = render(<A />)
4 |   expect(gbt('text')).not.toBeNull()
5 | })
6 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/named-imports.input.tsx:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | import { getByText as gbt } from '@testing-library/dom'
3 | 
4 | it('test', () => {
5 |   render(<A />)
6 |   expect(gbt(container, 'text')).not.toBeNull()
7 | })
8 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/non-empty-destructure.input.tsx:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | it('test', () => {
3 |   const { container, getByText } = render(<div />)
4 |   expect(getByText('text')).toBeInTheDocument()
5 | })
6 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/query-within.input.tsx:
--------------------------------------------------------------------------------
 1 | // @ts-nocheck
 2 | import React from 'react'
 3 | import { getByText } from '@testing-library/react'
 4 | 
 5 | it('test', () => {
 6 |   const { container } = render(<A />)
 7 |   expect(getByText(container, 'text')).toBeInTheDocument()
 8 |   expect(getByText(container, /text/)).toBeInTheDocument()
 9 | })
10 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/replace-member-expressions.input.tsx:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | import React from 'react'
3 | 
4 | it('test', () => {
5 |   const rendered = render(<A />)
6 |   expect(rendered.getByText('text')).toBeInTheDocument()
7 | })
8 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/respect-shadowed-vars.input.tsx:
--------------------------------------------------------------------------------
 1 | // @ts-nocheck
 2 | import React from 'react'
 3 | 
 4 | it('test', () => {
 5 |   const rendered = render(<A />)
 6 |   expect(rendered.getByText('text')).toBeInTheDocument()
 7 | 
 8 |   arr.forEach(() => {
 9 |     const rendered = render(<A />)
10 |     expect(rendered.foo('text')).toBeInTheDocument()
11 |   })
12 | })
13 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/reuse-existing-import.input.tsx:
--------------------------------------------------------------------------------
1 | // @ts-nocheck
2 | import { foo } from '@testing-library/react'
3 | 
4 | it('test', () => {
5 |   const { getByText } = render(<A />)
6 |   expect(getByText('text')).not.toBeNull()
7 | })
8 | 


--------------------------------------------------------------------------------
/src/transforms/__testfixtures__/jest-prefer-screen-queries/screen-and-within.input.tsx:
--------------------------------------------------------------------------------
 1 | // @ts-nocheck
 2 | import React from 'react'
 3 | import { getByText } from '@testing-library/react'
 4 | 
 5 | it('test', () => {
 6 |   const { container, getByTestId } = render(<A />)
 7 |   expect(getByText(container, 'text')).toBeInTheDocument()
 8 |   expect(getByTestId('id')).toBeInTheDocument()
 9 | })
10 | 


--------------------------------------------------------------------------------
/src/transforms/__tests__/__snapshots__/jest-no-manual-cleanup.test.ts.snap:
--------------------------------------------------------------------------------
 1 | // Jest Snapshot v1, https://goo.gl/fbAQLP
 2 | 
 3 | exports[`Keep lifecycle method call if 'cleanup' not the only call 1`] = `
 4 | "// @ts-nocheck
 5 | import { render, screen } from '@testing-library/react'
 6 | 
 7 | afterEach(() => {
 8 |   foo()
 9 | })
10 | "
11 | `;
12 | 
13 | exports[`Remove 'cleanup' call in non-lifecycle method 1`] = `
14 | "// @ts-nocheck
15 | import { render, screen } from '@testing-library/react'
16 | 
17 | it('test', () => {})
18 | "
19 | `;
20 | 
21 | exports[`Remove lifecycle method call if 'cleanup' is the only call in callback 1`] = `
22 | "// @ts-nocheck
23 | import { render, screen } from '@testing-library/react'
24 | "
25 | `;
26 | 
27 | exports[`Remove lifecycle method call if 'cleanup' is used as argument 1`] = `
28 | "// @ts-nocheck
29 | import { screen } from '@testing-library/react'
30 | "
31 | `;
32 | 


--------------------------------------------------------------------------------
/src/transforms/__tests__/__snapshots__/jest-prefer-presence-queries.test.ts.snap:
--------------------------------------------------------------------------------
 1 | // Jest Snapshot v1, https://goo.gl/fbAQLP
 2 | 
 3 | exports[`Use getBy in truthy queries 1`] = `
 4 | "// @ts-nocheck
 5 | it('test', () => {
 6 |   expect(getByTestId('id')).not.toBeNull()
 7 |   expect(getByText('id')).toBeTruthy()
 8 |   expect(getByRole('id')).toBeInTheDocument()
 9 |   expect(getByLabelText('id')).toBeDefined()
10 |   expect(screen.getByTestId('id')).not.toBeNull()
11 |   expect(screen.getByText('id')).toBeTruthy()
12 |   expect(screen.getByRole('id')).toBeInTheDocument()
13 |   expect(screen.getByLabelText('id')).toBeDefined()
14 |   expect(a.b.getByTestId('id')).not.toBeNull()
15 |   expect(a.b.getByText('id')).toBeTruthy()
16 |   expect(a.b.getByRole('id')).toBeInTheDocument()
17 |   expect(a.b.getByLabelText('id')).toBeDefined()
18 | })
19 | "
20 | `;
21 | 
22 | exports[`Use queryBy in falsy queries 1`] = `
23 | "// @ts-nocheck
24 | it('test', () => {
25 |   expect(queryByTestId('id')).toBeNull()
26 |   expect(queryByText('id')).toBeFalsy()
27 |   expect(queryByRole('id')).not.toBeInTheDocument()
28 |   expect(queryByLabelText('id')).not.toBeDefined()
29 |   expect(screen.queryByTestId('id')).toBeNull()
30 |   expect(screen.queryByText('id')).toBeFalsy()
31 |   expect(screen.queryByRole('id')).not.toBeInTheDocument()
32 |   expect(screen.queryByLabelText('id')).not.toBeDefined()
33 |   expect(a.b.queryByTestId('id')).toBeNull()
34 |   expect(a.b.queryByText('id')).toBeFalsy()
35 |   expect(a.b.queryByRole('id')).not.toBeInTheDocument()
36 |   expect(a.b.queryByLabelText('id')).not.toBeDefined()
37 | })
38 | "
39 | `;
40 | 


--------------------------------------------------------------------------------
/src/transforms/__tests__/__snapshots__/jest-prefer-screen-queries.test.ts.snap:
--------------------------------------------------------------------------------
  1 | // Jest Snapshot v1, https://goo.gl/fbAQLP
  2 | 
  3 | exports[`Add both screen and within if needed 1`] = `
  4 | "// @ts-nocheck
  5 | import React from 'react'
  6 | import { screen, within } from '@testing-library/react'
  7 | 
  8 | it('test', () => {
  9 |   const { container } = render(<A />)
 10 |   expect(within(container).getByText('text')).toBeInTheDocument()
 11 |   expect(screen.getByTestId('id')).toBeInTheDocument()
 12 | })
 13 | "
 14 | `;
 15 | 
 16 | exports[`Add rtl import after react 1`] = `
 17 | "// @ts-nocheck
 18 | import React from 'react'
 19 | 
 20 | import { screen } from '@testing-library/react'
 21 | 
 22 | it('test', () => {
 23 |   render(<A />)
 24 |   expect(screen.getByText('text')).toBeInTheDocument()
 25 | })
 26 | "
 27 | `;
 28 | 
 29 | exports[`Add screen to existing rtl import 1`] = `
 30 | "// @ts-nocheck
 31 | import { foo, screen } from '@testing-library/react'
 32 | 
 33 | it('test', () => {
 34 |   render(<A />)
 35 |   expect(screen.getByText('text')).not.toBeNull()
 36 | })
 37 | "
 38 | `;
 39 | 
 40 | exports[`Handled named destructure 1`] = `
 41 | "import { screen } from '@testing-library/react'
 42 | // @ts-nocheck
 43 | it('test', () => {
 44 |   render(<A />)
 45 |   expect(screen.getByText('text')).not.toBeNull()
 46 | })
 47 | "
 48 | `;
 49 | 
 50 | exports[`Handled named imports 1`] = `
 51 | "import { within } from '@testing-library/react'
 52 | 
 53 | it('test', () => {
 54 |   render(<A />)
 55 |   expect(within(container).getByText('text')).not.toBeNull()
 56 | })
 57 | "
 58 | `;
 59 | 
 60 | exports[`Keep multiple parameters if second is not string or regexp 1`] = `
 61 | "// @ts-nocheck
 62 | import React from 'react'
 63 | 
 64 | import { screen } from '@testing-library/react'
 65 | 
 66 | it('test', () => {
 67 |   render(<A />)
 68 |   expect(screen.getByText(container, options)).toBeInTheDocument()
 69 |   expect(screen.getByText(container, undefined, options)).toBeInTheDocument()
 70 | })
 71 | "
 72 | `;
 73 | 
 74 | exports[`Keep non empty destructure 1`] = `
 75 | "import { screen } from '@testing-library/react'
 76 | // @ts-nocheck
 77 | it('test', () => {
 78 |   const { container } = render(<div />)
 79 |   expect(screen.getByText('text')).toBeInTheDocument()
 80 | })
 81 | "
 82 | `;
 83 | 
 84 | exports[`Keep non query methods imports 1`] = `
 85 | "// @ts-nocheck
 86 | import { screen, within } from '@testing-library/react'
 87 | 
 88 | it('test', () => {
 89 |   render(<A />)
 90 |   expect(screen.getByText('text')).toBeInTheDocument()
 91 | })
 92 | "
 93 | `;
 94 | 
 95 | exports[`Keep object properties with rtl query names 1`] = `
 96 | "// @ts-nocheck
 97 | import React from 'react'
 98 | 
 99 | it('test', () => {
100 |   expect(obj.getByText('textA')).not.toBeNull()
101 | })
102 | "
103 | `;
104 | 
105 | exports[`Keep render result var if other props than queries used 1`] = `
106 | "// @ts-nocheck
107 | import React from 'react'
108 | 
109 | import { screen } from '@testing-library/react'
110 | 
111 | it('test', () => {
112 |   const rendered = render(<A />)
113 |   expect(screen.getByText('text')).toBeInTheDocument()
114 |   rendered.foo
115 | })
116 | "
117 | `;
118 | 
119 | exports[`Keep shadowed variables 1`] = `
120 | "// @ts-nocheck
121 | import React from 'react'
122 | 
123 | import { screen } from '@testing-library/react'
124 | 
125 | it('test', () => {
126 |   render(<A />)
127 |   expect(screen.getByText('text')).toBeInTheDocument()
128 | 
129 |   arr.forEach(() => {
130 |     const rendered = render(<A />)
131 |     expect(rendered.foo('text')).toBeInTheDocument()
132 |   })
133 | })
134 | "
135 | `;
136 | 
137 | exports[`Remove destructure and unused global var 1`] = `
138 | "import { screen } from '@testing-library/react'
139 | 
140 | it('test', () => {
141 |   render(<A />)
142 |   expect(screen.getByText('text')).toBeInTheDocument()
143 | })
144 | "
145 | `;
146 | 
147 | exports[`Remove destructure and unused local var 1`] = `
148 | "import { screen } from '@testing-library/react'
149 | // @ts-nocheck
150 | it('test', () => {
151 |   render(<A />)
152 |   expect(screen.getByText('text')).toBeInTheDocument()
153 | })
154 | "
155 | `;
156 | 
157 | exports[`Remove empty destructure 1`] = `
158 | "import { screen } from '@testing-library/react'
159 | // @ts-nocheck
160 | it('test', () => {
161 |   render({ foo: true })
162 | 
163 |   expect(screen.getByTestId('foo')).toBeInTheDocument()
164 | })
165 | "
166 | `;
167 | 
168 | exports[`Replace render result value usages 1`] = `
169 | "// @ts-nocheck
170 | import React from 'react'
171 | 
172 | import { screen } from '@testing-library/react'
173 | 
174 | it('test', () => {
175 |   render(<A />)
176 |   expect(screen.getByText('text')).toBeInTheDocument()
177 | })
178 | "
179 | `;
180 | 
181 | exports[`Transform query with more than one parameter to within 1`] = `
182 | "// @ts-nocheck
183 | import React from 'react'
184 | import { within } from '@testing-library/react'
185 | 
186 | it('test', () => {
187 |   const { container } = render(<A />)
188 |   expect(within(container).getByText('text')).toBeInTheDocument()
189 |   expect(within(container).getByText(/text/)).toBeInTheDocument()
190 | })
191 | "
192 | `;
193 | 


--------------------------------------------------------------------------------
/src/transforms/__tests__/jest-no-manual-cleanup.test.ts:
--------------------------------------------------------------------------------
 1 | import * as transform from '../no-manual-cleanup'
 2 | import { snapshotTest } from '../utils/testUtils'
 3 | 
 4 | snapshotTest(
 5 |   transform,
 6 |   {},
 7 |   'jest-no-manual-cleanup/cleanup-as-argument',
 8 |   "Remove lifecycle method call if 'cleanup' is used as argument",
 9 | )
10 | snapshotTest(
11 |   transform,
12 |   {},
13 |   'jest-no-manual-cleanup/keep-lifecycle-method',
14 |   "Keep lifecycle method call if 'cleanup' not the only call",
15 | )
16 | snapshotTest(
17 |   transform,
18 |   {},
19 |   'jest-no-manual-cleanup/remove-cleanup-call',
20 |   "Remove 'cleanup' call in non-lifecycle method",
21 | )
22 | snapshotTest(
23 |   transform,
24 |   {},
25 |   'jest-no-manual-cleanup/remove-lifecycle-method',
26 |   "Remove lifecycle method call if 'cleanup' is the only call in callback",
27 | )
28 | 


--------------------------------------------------------------------------------
/src/transforms/__tests__/jest-prefer-presence-queries.test.ts:
--------------------------------------------------------------------------------
 1 | import * as transform from '../prefer-presence-queries'
 2 | import { snapshotTest } from '../utils/testUtils'
 3 | 
 4 | snapshotTest(
 5 |   transform,
 6 |   {},
 7 |   'jest-prefer-presence-queries/truthy-queries',
 8 |   'Use getBy in truthy queries',
 9 | )
10 | snapshotTest(
11 |   transform,
12 |   {},
13 |   'jest-prefer-presence-queries/falsy-queries',
14 |   'Use queryBy in falsy queries',
15 | )
16 | 


--------------------------------------------------------------------------------
/src/transforms/__tests__/jest-prefer-screen-queries.test.ts:
--------------------------------------------------------------------------------
  1 | import * as transform from '../prefer-screen-queries'
  2 | import { snapshotTest } from '../utils/testUtils'
  3 | 
  4 | snapshotTest(
  5 |   transform,
  6 |   {},
  7 |   'jest-prefer-screen-queries/empty-destructure',
  8 |   'Remove empty destructure',
  9 | )
 10 | snapshotTest(
 11 |   transform,
 12 |   {},
 13 |   'jest-prefer-screen-queries/non-empty-destructure',
 14 |   'Keep non empty destructure',
 15 | )
 16 | snapshotTest(
 17 |   transform,
 18 |   {},
 19 |   'jest-prefer-screen-queries/destructure-and-unused-local-var',
 20 |   'Remove destructure and unused local var',
 21 | )
 22 | snapshotTest(
 23 |   transform,
 24 |   {},
 25 |   'jest-prefer-screen-queries/destructure-and-unused-global-var',
 26 |   'Remove destructure and unused global var',
 27 | )
 28 | snapshotTest(
 29 |   transform,
 30 |   {},
 31 |   'jest-prefer-screen-queries/named-destructure',
 32 |   'Handled named destructure',
 33 | )
 34 | snapshotTest(
 35 |   transform,
 36 |   {},
 37 |   'jest-prefer-screen-queries/named-imports',
 38 |   'Handled named imports',
 39 | )
 40 | snapshotTest(
 41 |   transform,
 42 |   {},
 43 |   'jest-prefer-screen-queries/keep-other-imports',
 44 |   'Keep non query methods imports',
 45 | )
 46 | snapshotTest(
 47 |   transform,
 48 |   {},
 49 |   'jest-prefer-screen-queries/reuse-existing-import',
 50 |   'Add screen to existing rtl import',
 51 | )
 52 | snapshotTest(
 53 |   transform,
 54 |   {},
 55 |   'jest-prefer-screen-queries/keep-object-props',
 56 |   'Keep object properties with rtl query names',
 57 | )
 58 | snapshotTest(
 59 |   transform,
 60 |   {},
 61 |   'jest-prefer-screen-queries/insert-import-after-react',
 62 |   'Add rtl import after react',
 63 | )
 64 | 
 65 | // within
 66 | snapshotTest(
 67 |   transform,
 68 |   {},
 69 |   'jest-prefer-screen-queries/query-within',
 70 |   'Transform query with more than one parameter to within',
 71 | )
 72 | snapshotTest(
 73 |   transform,
 74 |   {},
 75 |   'jest-prefer-screen-queries/screen-and-within',
 76 |   'Add both screen and within if needed',
 77 | )
 78 | snapshotTest(
 79 |   transform,
 80 |   { memberExpressions: true },
 81 |   'jest-prefer-screen-queries/keep-query-options',
 82 |   'Keep multiple parameters if second is not string or regexp',
 83 | )
 84 | 
 85 | 
 86 | // memberExpressions: true
 87 | snapshotTest(
 88 |   transform,
 89 |   { memberExpressions: true },
 90 |   'jest-prefer-screen-queries/replace-member-expressions',
 91 |   'Replace render result value usages',
 92 | )
 93 | snapshotTest(
 94 |   transform,
 95 |   { memberExpressions: true },
 96 |   'jest-prefer-screen-queries/keep-referenced-vars',
 97 |   'Keep render result var if other props than queries used',
 98 | )
 99 | snapshotTest(
100 |   transform,
101 |   { memberExpressions: true },
102 |   'jest-prefer-screen-queries/respect-shadowed-vars',
103 |   'Keep shadowed variables',
104 | )
105 | 


--------------------------------------------------------------------------------
/src/transforms/no-manual-cleanup.ts:
--------------------------------------------------------------------------------
 1 | import {
 2 |   Identifier,
 3 |   Transform,
 4 |   CallExpression,
 5 | } from 'jscodeshift'
 6 | import {
 7 |   getDeclarationScopePath,
 8 |   getParentScopePath,
 9 |   hasImport,
10 |   removeUnusedImport,
11 | } from './utils'
12 | 
13 | const RTL_MODULES_PREFIX = '@testing-library/'
14 | const CLEANUP_FUNCTION = 'cleanup'
15 | const JEST_LIFECYCLE_METHODS = [
16 |   'beforeEach',
17 |   'beforeAll',
18 |   'afterEach',
19 |   'afterAll',
20 | ]
21 | 
22 | const transform: Transform = (fileInfo, api) => {
23 |   const j = api.jscodeshift
24 |   const root = j(fileInfo.source)
25 | 
26 |   if (hasImport(j, root, RTL_MODULES_PREFIX, CLEANUP_FUNCTION)) {
27 |     root
28 |       .find(
29 |         j.Identifier,
30 |         {
31 |           name: CLEANUP_FUNCTION,
32 |         },
33 |       )
34 |       .filter(path => {
35 |         const declarationScopePath = getDeclarationScopePath(j, path, CLEANUP_FUNCTION)
36 |         return j(declarationScopePath).isOfType(j.Program)
37 |       })
38 |       .forEach(path => {
39 |         // 'cleanup()' could be called
40 |         if (
41 |           j(path.parentPath).isOfType(j.CallExpression)
42 |           && (path.parentPath.value as CallExpression).callee === path.value
43 |         ) {
44 |           const cleanupCall = path.parentPath as CallExpression
45 |           const parentScope = getParentScopePath(j, path)
46 | 
47 |           j(cleanupCall).remove()
48 | 
49 |           // 'cleanup()' is the only call in the scope, and was called from jest lifecycle method
50 |           if (!parentScope.value.body.length) {
51 |             const parentScopeFunction = parentScope.parentPath
52 |             if (
53 |               j(parentScopeFunction).isOfType(j.ArrowFunctionExpression)
54 |               || j(parentScopeFunction).isOfType(j.FunctionExpression)
55 |             ) {
56 |               // Check if function is a jest lyfecycle method callback
57 |               const parentCallExpression = parentScopeFunction.parentPath.parentPath
58 |               if (
59 |                 j(parentCallExpression).isOfType(j.CallExpression)
60 |                 && j((parentCallExpression.value as CallExpression).callee).isOfType(j.Identifier)
61 |                 && JEST_LIFECYCLE_METHODS.includes(
62 |                   ((parentCallExpression.value as CallExpression).callee as Identifier).name,
63 |                 )
64 |               ) {
65 |                 j(parentCallExpression).remove()
66 |               }
67 |             }
68 |           }
69 |         }
70 |       })
71 |       .forEach(path => {
72 |         // 'cleanup' could be passed directly to jest lifecycle method as an argument
73 |         const parent = path.parentPath.parentPath
74 |         if (
75 |           j(parent).isOfType(j.CallExpression)
76 |           && (parent.value as CallExpression).arguments.length === 1
77 |           && (parent.value as CallExpression).arguments[0] === path.value
78 |           && j((parent.value as CallExpression).callee).isOfType(j.Identifier)
79 |           && JEST_LIFECYCLE_METHODS.includes(
80 |             ((parent.value as CallExpression).callee as Identifier).name,
81 |           )
82 |         ) {
83 |           j(parent).remove()
84 |         }
85 | 
86 |       })
87 | 
88 |     removeUnusedImport(j, root.paths()[0], CLEANUP_FUNCTION)
89 |   }
90 | 
91 |   return root.toSource()
92 | }
93 | 
94 | export const parser = 'tsx'
95 | export default transform
96 | 


--------------------------------------------------------------------------------
/src/transforms/prefer-presence-queries.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 |   Identifier,
  3 |   Transform,
  4 |   JSCodeshift,
  5 |   MemberExpression,
  6 |   CallExpression,
  7 | } from 'jscodeshift'
  8 | 
  9 | const JEST_TRUTHY_ASSERTIONS = [
 10 |   '.not.toBeNull',
 11 |   '.toBeTruthy',
 12 |   '.not.toBeFalsy',
 13 |   '.toBeInTheDocument',
 14 |   '.toBeDefined',
 15 | ]
 16 | 
 17 | const JEST_FALSY_ASSERTIONS = [
 18 |   '.toBeNull',
 19 |   '.not.toBeTruthy',
 20 |   '.toBeFalsy',
 21 |   '.not.toBeInTheDocument',
 22 |   '.not.toBeDefined',
 23 | ]
 24 | 
 25 | const RTL_QUERIES = [
 26 |   'LabelText',
 27 |   'PlaceholderText',
 28 |   'Text',
 29 |   'AltText',
 30 |   'Title',
 31 |   'DisplayValue',
 32 |   'Role',
 33 |   'TestId',
 34 | ]
 35 | 
 36 | const RTL_TRUTHY_QUERY_PREFIX = 'getBy'
 37 | const RTL_FALSY_QUERY_PREFIX = 'queryBy'
 38 | 
 39 | const RTL_QUERY_METHODS = [
 40 |   ...RTL_QUERIES.map(query => `${RTL_TRUTHY_QUERY_PREFIX}${query}`),
 41 |   ...RTL_QUERIES.map(query => `${RTL_FALSY_QUERY_PREFIX}${query}`),
 42 | ]
 43 | 
 44 | const EXPECT_FUNCTION = 'expect'
 45 | 
 46 | function getCalleeName(j: JSCodeshift, node: CallExpression): string | null {
 47 |   let nameNode = node.callee
 48 |   while (nameNode && nameNode.type != 'Identifier') {
 49 |     if (nameNode.type === 'MemberExpression') {
 50 |       nameNode = (nameNode as MemberExpression).property
 51 |     } else {
 52 |       return null
 53 |     }
 54 |   }
 55 | 
 56 |   if (
 57 |     nameNode
 58 |     && nameNode.type === 'Identifier'
 59 |   ) {
 60 |     return nameNode.name
 61 |   }
 62 | 
 63 |   return null
 64 | }
 65 | 
 66 | const transform: Transform = (fileInfo, api) => {
 67 |   const j = api.jscodeshift
 68 |   const root = j(fileInfo.source)
 69 | 
 70 |   root
 71 |     .find(
 72 |       j.MemberExpression,
 73 |       {
 74 |         object: {
 75 |           type: 'CallExpression',
 76 |           callee: {
 77 |             type: 'Identifier',
 78 |             name: EXPECT_FUNCTION,
 79 |           },
 80 |         },
 81 |       },
 82 |     )
 83 |     .filter(path => (path.value.object as CallExpression).arguments.length === 1)
 84 |     .filter(path => {
 85 |       const { arguments: args } = path.value.object as CallExpression
 86 |       const firstArgument = args[0]
 87 |       // Callee could be an Identifier 'expect(getByText(...))' or member expression
 88 |       // 'expect(screen.getByText(...))'
 89 |       const calleeName = j(firstArgument).isOfType(j.CallExpression)
 90 |         && getCalleeName(j, firstArgument as CallExpression)
 91 |       return !!calleeName && RTL_QUERY_METHODS.includes(calleeName)
 92 |     })
 93 |     .forEach(path => {
 94 |       let jestAssertionName = `.${(path.value.property as Identifier).name}`
 95 |       let parentPath = path.parentPath
 96 |       while (
 97 |         j(parentPath).isOfType(j.MemberExpression)
 98 |         && j(parentPath.value.property).isOfType(j.Identifier)
 99 |       ) {
100 |         const name = ((parentPath.value as MemberExpression).property as Identifier).name
101 |         jestAssertionName += `.${name}`
102 |         parentPath = parentPath.parentPath
103 |       }
104 | 
105 |       const firstArgument = (path.value.object as CallExpression).arguments[0]
106 |       const calleeName = j(firstArgument).isOfType(j.CallExpression)
107 |         && getCalleeName(j, firstArgument as CallExpression)
108 | 
109 |       const calleeIdentifierPath = j(
110 |         (path.value.object as CallExpression).arguments,
111 |       )
112 |         .find(
113 |           j.Identifier,
114 |           {
115 |             name: calleeName,
116 |           },
117 |         )
118 | 
119 | 
120 |       if (
121 |         calleeName
122 |         && calleeName.startsWith(RTL_TRUTHY_QUERY_PREFIX)
123 |         && JEST_FALSY_ASSERTIONS.includes(jestAssertionName)
124 |       ) {
125 |         calleeIdentifierPath
126 |           .replaceWith(
127 |             j.identifier(
128 |               `${RTL_FALSY_QUERY_PREFIX}${calleeName.slice(RTL_TRUTHY_QUERY_PREFIX.length)}`,
129 |             ),
130 |           )
131 |       }
132 | 
133 |       if (
134 |         calleeName
135 |         && calleeName.startsWith(RTL_FALSY_QUERY_PREFIX)
136 |         && JEST_TRUTHY_ASSERTIONS.includes(jestAssertionName)
137 |       ) {
138 |         calleeIdentifierPath
139 |           .replaceWith(
140 |             j.identifier(
141 |               `${RTL_TRUTHY_QUERY_PREFIX}${calleeName.slice(RTL_FALSY_QUERY_PREFIX.length)}`,
142 |             ),
143 |           )
144 |       }
145 |     })
146 | 
147 |   return root.toSource()
148 | }
149 | 
150 | export const parser = 'tsx'
151 | export default transform
152 | 


--------------------------------------------------------------------------------
/src/transforms/prefer-screen-queries.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 |   Identifier,
  3 |   Transform,
  4 |   JSCodeshift,
  5 |   MemberExpression,
  6 |   ImportDeclaration,
  7 |   Options,
  8 |   CallExpression,
  9 |   ASTPath,
 10 | } from 'jscodeshift'
 11 | import {
 12 |   getDeclarationScopePath,
 13 |   getParentScopePath,
 14 |   hasImport,
 15 |   insertImport,
 16 |   removeUnusedIdentifierDeclaration,
 17 |   replaceMethodNames,
 18 | } from './utils'
 19 | 
 20 | export interface TransformOptions extends Options {
 21 |   memberExpressions?: boolean | string
 22 | }
 23 | 
 24 | const RTL_VARIANTS = [
 25 |   'getBy',
 26 |   'getAllBy',
 27 |   'queryBy',
 28 |   'queryAllBy',
 29 |   'findBy',
 30 |   'findAllBy',
 31 | ]
 32 | 
 33 | const RTL_QUERIES = [
 34 |   'LabelText',
 35 |   'PlaceholderText',
 36 |   'Text',
 37 |   'AltText',
 38 |   'Title',
 39 |   'DisplayValue',
 40 |   'Role',
 41 |   'TestId',
 42 | ]
 43 | 
 44 | const SCREEN_OBJECT_NAME = 'screen'
 45 | const WITHIN_METHOD_NAME = 'within'
 46 | const RTL_MODULES_PREFIX = '@testing-library/'
 47 | const RTL_SOURCE_MODULE = `${RTL_MODULES_PREFIX}react`
 48 | const APPEND_RTL_IMPORT_AFTER_MODULE = 'react'
 49 | 
 50 | export const RTL_QUERY_METHODS = RTL_VARIANTS.reduce(
 51 |   (methods, variant) => {
 52 |     RTL_QUERIES.forEach(query => methods.push(`${variant}${query}`))
 53 |     return methods
 54 |   },
 55 |   [] as string[],
 56 | )
 57 | 
 58 | const getScreenMemberExpression = (j: JSCodeshift, propName: string): MemberExpression =>
 59 |   j.memberExpression(
 60 |     j.identifier(SCREEN_OBJECT_NAME),
 61 |     j.identifier(propName),
 62 |   )
 63 | 
 64 | const transform: Transform = (fileInfo, api, options: TransformOptions) => {
 65 |   const j = api.jscodeshift
 66 |   const root = j(fileInfo.source)
 67 | 
 68 |   let hasScreenTransformations = false
 69 |   let hasWithinTransformation = false
 70 | 
 71 |   // Find all destructured properties with rtl query method names
 72 |   root
 73 |     .find(
 74 |       j.VariableDeclarator,
 75 |       {
 76 |         id: {
 77 |           type: 'ObjectPattern',
 78 |         },
 79 |       })
 80 |     .forEach(path => {
 81 |       let replacedNames = false
 82 |       j(path)
 83 |         .find(j.ObjectProperty)
 84 |         .filter(opPath => j(opPath.value.key).isOfType(j.Identifier))
 85 |         .filter(opPath => RTL_QUERY_METHODS.includes(
 86 |           (opPath.value.key as Identifier).name),
 87 |         )
 88 |         .forEach(opPath => {
 89 |           const propName = (opPath.value.key as Identifier).name
 90 |           const localName = (opPath.value.value as Identifier).name
 91 |           // Replace with screen.<method> call
 92 |           replacedNames = replaceMethodNames(
 93 |             j,
 94 |             getParentScopePath(j, opPath),
 95 |             localName,
 96 |             getScreenMemberExpression(j, propName),
 97 |           )
 98 |         })
 99 |         .forEach(opPath => j(opPath).remove())
100 | 
101 |       hasScreenTransformations = hasScreenTransformations || replacedNames
102 |     })
103 | 
104 |   if (hasScreenTransformations) {
105 |     // Cleanup empty destructure assignments and unused variables
106 |     root
107 |       .find(
108 |         j.VariableDeclarator,
109 |         {
110 |           id: {
111 |             type: 'ObjectPattern',
112 |           },
113 |         })
114 |       .forEach(path => {
115 |         // Remove empty destructures
116 |         if (!j(path.value.id).find(j.ObjectProperty).size()) {
117 |           const { init } = path.value
118 |           if (init) {
119 |             // Replace with right assignmnet part
120 |             const replaced = j(path.parentPath.parentPath).replaceWith(
121 |               j.expressionStatement(init),
122 |             ).paths()[0]
123 | 
124 |             if (j(replaced.value.expression).isOfType(j.Identifier)) {
125 |               // render() result was assigned to identifier
126 |               // Remove identifier declaration if it is not used
127 |               const parentPath = replaced.parentPath
128 |               const idName = (replaced.value.expression as Identifier).name
129 | 
130 |               j(replaced).remove()
131 |               removeUnusedIdentifierDeclaration(j, parentPath, idName)
132 |             }
133 |           }
134 |         }
135 |       })
136 |   }
137 | 
138 |   if (options.memberExpressions === true || options.memberExpressions === 'true') {
139 |     // Find all rtl queries, called from render result
140 |     // Example:
141 |     // const result = render();
142 |     // expect(render.getByText('text')).toBeInTheDocument()
143 |     root
144 |       .find(
145 |         j.CallExpression,
146 |         {
147 |           callee: {
148 |             type: 'MemberExpression',
149 |             object: {
150 |               type: 'Identifier',
151 |             },
152 |             property: {
153 |               type: 'Identifier',
154 |             },
155 |           },
156 |         },
157 |       )
158 |       .filter(path => RTL_QUERY_METHODS.includes(
159 |         ((path.value.callee as MemberExpression).property as Identifier).name,
160 |       ))
161 |       .forEach(path => {
162 |         const objectName = ((path.value.callee as MemberExpression).object as Identifier).name
163 |         const objectScope = getDeclarationScopePath(j, path, objectName)
164 |         if (objectScope) {
165 |           // Replace all references with screen
166 |           j(objectScope)
167 |             .find(
168 |               j.CallExpression,
169 |               {
170 |                 callee: {
171 |                   type: 'MemberExpression',
172 |                   object: {
173 |                     name: objectName,
174 |                     type: 'Identifier',
175 |                   },
176 |                 },
177 |               },
178 |             )
179 |             .filter(referencePath =>
180 |               getDeclarationScopePath(j, referencePath, objectName) === objectScope,
181 |             )
182 |             .forEach(referencePath => {
183 |               const propName =
184 |                 ((referencePath.value.callee as MemberExpression).property as Identifier).name
185 |               j(referencePath).replaceWith(
186 |                 j.callExpression(
187 |                   j.memberExpression(j.identifier(SCREEN_OBJECT_NAME), j.identifier(propName)),
188 |                   referencePath.value.arguments,
189 |                 ),
190 |               )
191 | 
192 |               hasScreenTransformations = true
193 |             })
194 | 
195 |           // Remove declaration
196 |           removeUnusedIdentifierDeclaration(j, path, objectName)
197 |         }
198 |       })
199 |   }
200 | 
201 |   // Find and replace rtl query named imports
202 |   root
203 |     .find(j.ImportSpecifier)
204 |     .filter(path => j(path.parentPath.parentPath.value).isOfType(j.ImportDeclaration))
205 |     .filter(path => !!(path.parentPath.parentPath.value as ImportDeclaration)
206 |       .source
207 |       .value
208 |       ?.toString()
209 |       .startsWith(RTL_MODULES_PREFIX),
210 |     )
211 |     .filter(path => RTL_QUERY_METHODS.includes(path.value.imported.name))
212 |     .forEach(path => {
213 |       const importedName = path.value.imported.name
214 |       const localName = path.value.local?.name ?? importedName
215 | 
216 |       const transformedNodes = root
217 |         .find(j.Identifier, { name: localName })
218 |         .filter(idPath => j(getDeclarationScopePath(j, idPath, localName)).isOfType(j.Program))
219 |         .filter(idPath => j(idPath.parentPath.value).isOfType(j.CallExpression))
220 |         .forEach(idPath => {
221 |           const parentCallExpression = idPath.parentPath as ASTPath<CallExpression>
222 |           const args = parentCallExpression.value.arguments
223 |           j(parentCallExpression).replaceWith(
224 |             j.callExpression(
225 |               j.memberExpression(
226 |                 j.callExpression(j.identifier(WITHIN_METHOD_NAME), [args[0]]),
227 |                 j.identifier(importedName),
228 |               ),
229 |               args.slice(1),
230 |             ),
231 |           )
232 |         })
233 | 
234 |       hasWithinTransformation = !!transformedNodes.size()
235 | 
236 |       j(path).remove()
237 | 
238 |       const declaration = path.parentPath.parentPath.value as ImportDeclaration
239 |       if (!declaration.specifiers.length) {
240 |         j(path.parentPath.parentPath).remove()
241 |       }
242 |     })
243 | 
244 |   // Check if file still has screen usages (all could be replaced with within())
245 |   const hasScreenReferences = !!root
246 |     .find(
247 |       j.CallExpression,
248 |       {
249 |         callee: {
250 |           type: 'MemberExpression',
251 |           object: {
252 |             type: 'Identifier',
253 |             name: SCREEN_OBJECT_NAME,
254 |           },
255 |           property: {
256 |             type: 'Identifier',
257 |           },
258 |         },
259 |       },
260 |     )
261 |     .filter(path => RTL_QUERY_METHODS.includes(
262 |       ((path.value.callee as MemberExpression).property as Identifier).name,
263 |     ))
264 |     .size()
265 | 
266 |   const needScreenImport = hasScreenTransformations
267 |     && hasScreenReferences
268 |     && !hasImport(j, root, RTL_MODULES_PREFIX, SCREEN_OBJECT_NAME)
269 |   const needWithinImport = hasWithinTransformation
270 |     && !hasImport(j, root, RTL_MODULES_PREFIX, WITHIN_METHOD_NAME)
271 | 
272 |   if (needScreenImport) {
273 |     insertImport(j, root, RTL_SOURCE_MODULE, SCREEN_OBJECT_NAME, APPEND_RTL_IMPORT_AFTER_MODULE)
274 |   }
275 | 
276 |   if (needWithinImport) {
277 |     insertImport(j, root, RTL_SOURCE_MODULE, WITHIN_METHOD_NAME, APPEND_RTL_IMPORT_AFTER_MODULE)
278 |   }
279 | 
280 |   return root.toSource()
281 | }
282 | 
283 | export const parser = 'tsx'
284 | export default transform
285 | 


--------------------------------------------------------------------------------
/src/transforms/utils/index.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 |   ASTPath,
  3 |   BlockStatement,
  4 |   Identifier,
  5 |   JSCodeshift,
  6 |   Node,
  7 |   Program,
  8 |   VariableDeclarator,
  9 |   ObjectPattern,
 10 |   FunctionDeclaration,
 11 |   Collection,
 12 |   AssignmentExpression,
 13 |   ImportDeclaration,
 14 |   TSTypeReference,
 15 |   ImportSpecifier,
 16 | } from 'jscodeshift'
 17 | 
 18 | export function getParentScopePath(
 19 |   j: JSCodeshift,
 20 |   path: ASTPath,
 21 | ): ASTPath<BlockStatement> | ASTPath<Program> {
 22 |   const isGlobalScope = path.scope.isGlobal
 23 |   const scopeType = isGlobalScope ? j.Program : j.BlockStatement
 24 | 
 25 |   let scopePath = path.parentPath
 26 |   while (scopePath) {
 27 |     if (j(scopePath).isOfType(scopeType)) {
 28 |       return scopePath.parentPath
 29 |     }
 30 | 
 31 |     scopePath = scopePath.parentPath
 32 |   }
 33 | 
 34 |   return scopePath.parentPath
 35 | }
 36 | 
 37 | export function isScopeType(
 38 |   j: JSCodeshift,
 39 |   path: ASTPath,
 40 | ): path is ASTPath<Program> | ASTPath<BlockStatement> {
 41 |   return j(path).isOfType(j.Program) || j(path).isOfType(j.BlockStatement)
 42 | }
 43 | 
 44 | export function getDeclarationScopePath(
 45 |   j: JSCodeshift,
 46 |   path: ASTPath,
 47 |   name: string,
 48 | ): ASTPath<BlockStatement> | ASTPath<Program> {
 49 |   let scopePath = path
 50 |   while (scopePath) {
 51 |     if (isScopeType(j, scopePath) && findDeclarationInScope(j, scopePath, name)) {
 52 |       return scopePath
 53 |     }
 54 |     scopePath = scopePath.parentPath
 55 |   }
 56 | 
 57 |   return scopePath
 58 | }
 59 | 
 60 | export function getIdentifierDeclaration(
 61 |   j: JSCodeshift,
 62 |   path: ASTPath<Identifier>,
 63 | ): ASTPath | null {
 64 |   const idName = path.value.name
 65 | 
 66 |   let scopePath = path
 67 |   while (scopePath) {
 68 |     const declaration = isScopeType(j, scopePath)
 69 |       && findDeclarationInScope(j, scopePath, idName)
 70 |     if (declaration) {
 71 |       return declaration
 72 |     }
 73 |     scopePath = scopePath.parentPath
 74 |   }
 75 | 
 76 |   return scopePath
 77 | }
 78 | 
 79 | type DeclarationPath =
 80 |   | ASTPath<VariableDeclarator>
 81 |   | ASTPath<ObjectPattern>
 82 |   | ASTPath<FunctionDeclaration>
 83 | 
 84 | export function findDeclarationInScope(
 85 |   j: JSCodeshift,
 86 |   scope: ASTPath<BlockStatement> | ASTPath<Program>,
 87 |   declarationName: string,
 88 | ): DeclarationPath | null {
 89 |   const identifierFilter = {
 90 |     type: 'Identifier',
 91 |     name: declarationName,
 92 |   }
 93 | 
 94 |   const variableDeclarator = j(scope)
 95 |     .find(
 96 |       j.VariableDeclarator,
 97 |       {
 98 |         id: identifierFilter,
 99 |       },
100 |     )
101 | 
102 |   const objectPattern = j(scope)
103 |     .find(j.ObjectPattern)
104 |     .find(
105 |       j.ObjectProperty,
106 |       {
107 |         value: identifierFilter,
108 |       },
109 |     )
110 | 
111 |   const funcitonDeclaration = j(scope)
112 |     .find(
113 |       j.FunctionDeclaration,
114 |       {
115 |         id: identifierFilter,
116 |       },
117 |     )
118 | 
119 |   const importDeclaration = j(scope)
120 |     .find(
121 |       j.ImportSpecifier,
122 |       {
123 |         local: identifierFilter,
124 |       },
125 |     )
126 | 
127 |   const suitableCollection = [
128 |     variableDeclarator,
129 |     objectPattern,
130 |     funcitonDeclaration,
131 |     importDeclaration,
132 |   ]
133 |     .find(collection => collection.size() > 0) ?? null
134 | 
135 |   return (suitableCollection as Collection)
136 |       ?.filter(path => getParentScopePath(j, path) === scope)
137 |       .paths()[0] ?? null
138 | 
139 | }
140 | 
141 | export function replaceMethodNames(
142 |   j: JSCodeshift,
143 |   root: ASTPath,
144 |   replaceFrom: string,
145 |   replaceWith: Node,
146 | ): boolean {
147 |   return !!j(root)
148 |     .find(j.Identifier, { name: replaceFrom })
149 |     // Avoid replacing shadowed identifiers
150 |     .filter(path => root === getDeclarationScopePath(j, path, path.value.name))
151 |     .filter(path => j(path.parentPath).isOfType(j.CallExpression))
152 |     .replaceWith(() => replaceWith)
153 |     .size()
154 | }
155 | 
156 | export function isVariableReferenced(
157 |   j: JSCodeshift,
158 |   root: ASTPath,
159 |   name: string,
160 | ): boolean {
161 |   return !!j(root)
162 |     .find(j.Identifier, { name })
163 |     // Avoid replacing shadowed identifiers
164 |     .filter(path => root === getDeclarationScopePath(j, path, path.value.name))
165 |     // Filter out variable declaration
166 |     .filter(path => !(
167 |       j(path.parentPath.value).isOfType(j.AssignmentExpression)
168 |       && ((path.parentPath.value as AssignmentExpression).left === path.value)
169 |     ))
170 |     .filter(path => !(
171 |       j(path.parentPath).isOfType(j.VariableDeclarator)
172 |       && j(path.parentPath.value.id).isOfType(j.Identifier)
173 |       && path.parentPath.value.id.name === name
174 |     ))
175 |     .size()
176 | }
177 | 
178 | export function removeUnusedIdentifierDeclaration(
179 |   j: JSCodeshift,
180 |   root: ASTPath,
181 |   name: string,
182 | ): void {
183 |   // Find declaration and remove if it is not referenced
184 |   const declarationScopePath = getDeclarationScopePath(j, root, name)
185 |   const hasReferences = isVariableReferenced(j, declarationScopePath, name)
186 |   if (!hasReferences) {
187 |     const declarationPath = findDeclarationInScope(j, declarationScopePath, name)
188 |     if (declarationPath && j(declarationPath).isOfType(j.VariableDeclarator)) {
189 |       const { init, id } = declarationPath.value as VariableDeclarator
190 |       let identifierTypeName: string | undefined
191 |       if (j(id).isOfType(Identifier)) {
192 |         const typeAnnotation = (id as Identifier).typeAnnotation
193 | 
194 |         if (
195 |           typeAnnotation
196 |           && j(typeAnnotation.typeAnnotation).isOfType(TSTypeReference)
197 |           && j((typeAnnotation.typeAnnotation as TSTypeReference).typeName).isOfType(Identifier)
198 |         ) {
199 |           identifierTypeName =
200 |             ((typeAnnotation.typeAnnotation as TSTypeReference).typeName as Identifier).name
201 |         }
202 |       }
203 |       if (init) {
204 |         j(declarationPath.parentPath.parentPath).replaceWith(
205 |           j.expressionStatement(init),
206 |         )
207 |       } else {
208 |         // Variable declaration with no assignment
209 |         j(declarationPath.parentPath.parentPath).remove()
210 |       }
211 | 
212 |       if (identifierTypeName) {
213 |         // Check if type can be removed from import
214 |         let parentPath = root
215 |         while (!j(parentPath).isOfType(Program)) {
216 |           parentPath = parentPath.parentPath
217 |         }
218 | 
219 |         if (parentPath) {
220 |           removeUnusedImport(j, parentPath as ASTPath<Program>, identifierTypeName)
221 |         }
222 |       }
223 |     }
224 | 
225 |     // Assignments to removed variable could still be left
226 |     j(declarationScopePath)
227 |       .find(
228 |         j.AssignmentExpression,
229 |         {
230 |           left: {
231 |             type: 'Identifier',
232 |             name: name,
233 |           },
234 |         })
235 |       .filter(assignmentPath =>
236 |         (assignmentPath.value.left as Identifier).name === name,
237 |       )
238 |       .filter(assignmentPath => !getDeclarationScopePath(j, assignmentPath, name))
239 |       .forEach(assignmentPath => j(assignmentPath).replaceWith(
240 |         j.expressionStatement(assignmentPath.value.right)),
241 |       )
242 |   }
243 | }
244 | 
245 | export function removeUnusedImport(j: JSCodeshift, root: ASTPath<Program>, name: string): void {
246 |   const hasReferences = !!j(root)
247 |     .find(j.Identifier, { name })
248 |     .filter(path => !j(path.parentPath).isOfType(j.ImportSpecifier))
249 |     .size()
250 | 
251 |   if (!hasReferences) {
252 |     j(root)
253 |       .find(
254 |         j.ImportSpecifier,
255 |         {
256 |           local: {
257 |             type: 'Identifier',
258 |             name,
259 |           },
260 |         },
261 |       )
262 |       .forEach(path => {
263 |         const importDeclaration = path.parentPath.parentPath
264 |         j(path).remove()
265 | 
266 |         if (!(importDeclaration.value as ImportDeclaration).specifiers.length) {
267 |           j(importDeclaration).remove()
268 |         }
269 |       })
270 |   }
271 | }
272 | 
273 | export function insertImport(
274 |   j: JSCodeshift,
275 |   root: Collection,
276 |   moduleName: string,
277 |   importedName: string,
278 |   afterModuleName?: string,
279 | ): void {
280 |   // Add imported to existing module
281 |   const existingImportPath = root
282 |     .find(
283 |       j.ImportDeclaration,
284 |       {
285 |         source: {
286 |           type: 'StringLiteral',
287 |           value: moduleName,
288 |         },
289 |       },
290 |     )
291 |     .filter(path => path.value.specifiers.every(
292 |       specifier => j(specifier).isOfType(j.ImportSpecifier)
293 |         && (specifier as ImportSpecifier).imported.name !== importedName,
294 |     ))
295 |     .forEach(path => path.value.specifiers.push(
296 |       j.importSpecifier(j.identifier(importedName)),
297 |     ))
298 | 
299 |   if (!existingImportPath.size()) {
300 |     // Module import was not found, need to add new import
301 |     const addedImportDeclaration = j.importDeclaration(
302 |       [j.importSpecifier(j.identifier(importedName))],
303 |       j.stringLiteral(moduleName),
304 |     )
305 | 
306 |     const hasAddAfterImport = root
307 |       .find(
308 |         j.ImportDeclaration,
309 |         {
310 |           source: {
311 |             type: 'StringLiteral',
312 |             value: afterModuleName,
313 |           },
314 |         },
315 |       )
316 |       .insertAfter(addedImportDeclaration)
317 | 
318 |     // Cannot add after desired import, adding as a first line
319 |     if (!hasAddAfterImport.size()) {
320 |       root
321 |         .find(j.Program)
322 |         .forEach(path => path.value.body.unshift(addedImportDeclaration))
323 |     }
324 |   }
325 | }
326 | 
327 | export function hasImport(
328 |   j: JSCodeshift,
329 |   root: Collection,
330 |   moduleNamePrefix: string,
331 |   importedName: string,
332 | ): boolean {
333 |   return !!root
334 |     .find(j.ImportDeclaration)
335 |     .filter(path => !!path.value.source.value?.toString().startsWith(moduleNamePrefix))
336 |     .find(
337 |       j.ImportSpecifier,
338 |       {
339 |         imported: {
340 |           type: 'Identifier',
341 |           name: importedName,
342 |         },
343 |       },
344 |     )
345 |     .size()
346 | }
347 | 


--------------------------------------------------------------------------------
/src/transforms/utils/testUtils.ts:
--------------------------------------------------------------------------------
 1 | // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 2 | // @ts-ignore no such function in typings
 3 | import { applyTransform } from 'jscodeshift/dist/testUtils'
 4 | import { existsSync, readFileSync } from 'fs'
 5 | import { resolve } from 'path'
 6 | import { Transform, Options, FileInfo } from 'jscodeshift'
 7 | import { format } from 'prettier'
 8 | 
 9 | export const snapshotTest = (
10 |   module: { default: Transform, parser?: string },
11 |   options: Options,
12 |   inputFileName: string,
13 |   testName?: string,
14 | ): void => {
15 |   it(testName || 'transforms correctly', () => {
16 |     const transformed = applyTransform(module, options, getInput(inputFileName))
17 |     const formatted = format(transformed, {
18 |       parser: 'typescript',
19 |       singleQuote: true,
20 |       semi: false,
21 |       trailingComma: 'all',
22 |       printWidth: 90,
23 |       arrowParens: 'avoid',
24 |     })
25 |     expect(formatted).toMatchSnapshot()
26 |   })
27 | }
28 | 
29 | function getInput(moduleName: string): FileInfo {
30 |   const MODULE_EXTS = ['ts', 'tsx']
31 |   const paths = MODULE_EXTS.map(ext =>
32 |     resolve(__dirname, `../__testfixtures__/${moduleName}.input.${ext}`),
33 |   )
34 |   const fixturePath = paths.find(path => existsSync(path))
35 |   if (!fixturePath) {
36 |     throw new Error(`Unable to find fixture ${moduleName}`)
37 |   }
38 | 
39 |   return {
40 |     path: fixturePath,
41 |     source: readFileSync(fixturePath).toString(),
42 |   }
43 | }
44 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     /* Visit https://aka.ms/tsconfig.json to read more about this file */
 4 | 
 5 |     /* Basic Options */
 6 |     // "incremental": true,                   /* Enable incremental compilation */
 7 |     "target": "es5",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
 8 |     "module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
 9 |     "lib": [
10 |       "ES2015",
11 |       "ES2016",
12 |       "ES2017",
13 |       "ES2018",
14 |       "ES2019"
15 |     ],                             /* Specify library files to be included in the compilation. */
16 |     // "allowJs": true,                       /* Allow javascript files to be compiled. */
17 |     // "checkJs": true,                       /* Report errors in .js files. */
18 |     "jsx": "react",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
19 |     // "declaration": true,                   /* Generates corresponding '.d.ts' file. */
20 |     // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
21 |     // "sourceMap": true,                     /* Generates corresponding '.map' file. */
22 |     // "outFile": "./",                       /* Concatenate and emit output to single file. */
23 |     // "outDir": "./",                        /* Redirect output structure to the directory. */
24 |     // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
25 |     // "composite": true,                     /* Enable project compilation */
26 |     // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
27 |     // "removeComments": true,                /* Do not emit comments to output. */
28 |     // "noEmit": true,                        /* Do not emit outputs. */
29 |     // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
30 |     // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
31 |     // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
32 | 
33 |     /* Strict Type-Checking Options */
34 |     "strict": true,                           /* Enable all strict type-checking options. */
35 |     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
36 |     // "strictNullChecks": true,              /* Enable strict null checks. */
37 |     // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
38 |     // "strictBindCallApply": true,           /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
39 |     // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
40 |     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
41 |     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
42 | 
43 |     /* Additional Checks */
44 |     // "noUnusedLocals": true,                /* Report errors on unused locals. */
45 |     // "noUnusedParameters": true,            /* Report errors on unused parameters. */
46 |     // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
47 |     // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
48 | 
49 |     /* Module Resolution Options */
50 |     // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
51 |     // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
52 |     // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
53 |     // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
54 |     // "typeRoots": [],                       /* List of folders to include type definitions from. */
55 |     // "types": [],                           /* Type declaration files to be included in compilation. */
56 |     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
57 |     "esModuleInterop": true,                  /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
58 |     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
59 |     // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
60 | 
61 |     /* Source Map Options */
62 |     // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
63 |     // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
64 |     // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
65 |     // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
66 | 
67 |     /* Experimental Options */
68 |     // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
69 |     // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
70 | 
71 |     /* Advanced Options */
72 |     "skipLibCheck": true,                     /* Skip type checking of declaration files. */
73 |     "forceConsistentCasingInFileNames": true  /* Disallow inconsistently-cased references to the same file. */
74 |   },
75 |   "exclude" : ["**/__testfixtures__/*"]
76 | }
77 | 


--------------------------------------------------------------------------------