@tanstack/eslint-plugin-query 5.59.4 → 5.59.20

package/src/__tests__/stable-query-client.test.ts

@@ -1,192 +0,0 @@
-import { RuleTester } from '@typescript-eslint/rule-tester'
-import { rule } from '../rules/stable-query-client/stable-query-client.rule'
-import { normalizeIndent } from './test-utils'
-
-const ruleTester = new RuleTester()
-
-ruleTester.run('stable-query-client', rule, {
-  valid: [
-    {
-      name: 'QueryClient is stable when wrapped in React.useState',
-      code: normalizeIndent`
-        import { QueryClient } from "@tanstack/react-query";
-
-        function Component() {
-          const [queryClient] = React.useState(() => new QueryClient());
-          return;
-        }
-      `,
-    },
-    {
-      name: 'QueryClient is stable when wrapped in useState',
-      code: normalizeIndent`
-        import { QueryClient } from "@tanstack/react-query";
-
-        function Component() {
-          const [queryClient] = useState(() => new QueryClient());
-          return;
-        }
-      `,
-    },
-    {
-      name: 'QueryClient is stable when wrapped in React.useMemo',
-      code: normalizeIndent`
-          import { QueryClient } from "@tanstack/react-query";
-
-          function Component() {
-            const [queryClient] = React.useMemo(() => new QueryClient(), []);
-            return;
-          }
-        `,
-    },
-    {
-      name: 'QueryClient is stable when wrapped in useAnything',
-      code: normalizeIndent`
-          import { QueryClient } from "@tanstack/react-query";
-
-          function Component() {
-            const [queryClient] = useAnything(() => new QueryClient());
-            return;
-          }
-        `,
-    },
-    {
-      name: 'QueryClient is imported from a non-tanstack package',
-      code: normalizeIndent`
-        import { QueryClient } from "other-library";
-
-        function Component() {
-          const queryClient = new QueryClient();
-          return;
-        }
-      `,
-    },
-    {
-      name: 'QueryClient is not imported from @tanstack/react-query',
-      code: normalizeIndent`
-        import { QueryClient } from "@tanstack/solid-query";
-
-        function Component() {
-          const queryClient = new QueryClient();
-          return;
-        }
-      `,
-    },
-    {
-      name: 'QueryClient is invoked outside of a function',
-      code: normalizeIndent`
-        import { QueryClient } from "@tanstack/solid-query";
-
-        const queryClient = new QueryClient();
-
-        function Component() {
-          return;
-        }
-      `,
-    },
-    {
-      name: 'QueryClient is invoked in a non-component function',
-      code: normalizeIndent`
-        import { QueryClient } from "@tanstack/solid-query";
-
-        function someFn() {
-          const queryClient = new QueryClient();
-          return;
-        }
-      `,
-    },
-    {
-      name: 'QueryClient is invoked in an async (react server) component',
-      code: normalizeIndent`
-        import { QueryClient } from "@tanstack/solid-query";
-
-        async function AsyncComponent() {
-          const queryClient = new QueryClient();
-          return;
-        }
-      `,
-    },
-  ],
-  invalid: [
-    {
-      name: 'QueryClient is not stable when it is not wrapped in React.useState in component',
-      code: normalizeIndent`
-        import { QueryClient } from "@tanstack/react-query";
-
-        function Component() {
-          const queryClient = new QueryClient();
-          return;
-        }
-      `,
-      output: normalizeIndent`
-        import { QueryClient } from "@tanstack/react-query";
-
-        function Component() {
-          const [queryClient] = React.useState(() => new QueryClient());
-          return;
-        }
-      `,
-      errors: [{ messageId: 'unstable' }],
-    },
-    {
-      name: 'QueryClient is not stable when it is not wrapped in React.useState in custom hook',
-      code: normalizeIndent`
-        import { QueryClient } from "@tanstack/react-query";
-
-        function useHook() {
-          const queryClient = new QueryClient();
-          return;
-        }
-      `,
-      output: normalizeIndent`
-        import { QueryClient } from "@tanstack/react-query";
-
-        function useHook() {
-          const [queryClient] = React.useState(() => new QueryClient());
-          return;
-        }
-      `,
-      errors: [{ messageId: 'unstable' }],
-    },
-    {
-      name: 'preserve QueryClient options',
-      code: normalizeIndent`
-        import { QueryClient } from "@tanstack/react-query";
-
-        function Component() {
-          const queryClient = new QueryClient({ defaultOptions: { /* */ } });
-          return;
-        }
-      `,
-      output: normalizeIndent`
-        import { QueryClient } from "@tanstack/react-query";
-
-        function Component() {
-          const [queryClient] = React.useState(() => new QueryClient({ defaultOptions: { /* */ } }));
-          return;
-        }
-      `,
-      errors: [{ messageId: 'unstable' }],
-    },
-    {
-      name: 'preserve QueryClient variable declarator name',
-      code: normalizeIndent`
-        import { QueryClient } from "@tanstack/react-query";
-
-        function Component() {
-          const customName = new QueryClient();
-          return;
-        }
-      `,
-      output: normalizeIndent`
-        import { QueryClient } from "@tanstack/react-query";
-
-        function Component() {
-          const [customName] = React.useState(() => new QueryClient());
-          return;
-        }
-      `,
-      errors: [{ messageId: 'unstable' }],
-    },
-  ],
-})

package/src/__tests__/test-utils.test.ts

@@ -1,104 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import {
-  expectArrayEqualIgnoreOrder,
-  generateInterleavedCombinations,
-  generatePartialCombinations,
-  generatePermutations,
-} from './test-utils'
-
-describe('test-utils', () => {
-  describe('generatePermutations', () => {
-    const testCases = [
-      {
-        input: ['a', 'b', 'c'],
-        expected: [
-          ['a', 'b', 'c'],
-          ['a', 'c', 'b'],
-          ['b', 'a', 'c'],
-          ['b', 'c', 'a'],
-          ['c', 'a', 'b'],
-          ['c', 'b', 'a'],
-        ],
-      },
-      {
-        input: ['a', 'b'],
-        expected: [
-          ['a', 'b'],
-          ['b', 'a'],
-        ],
-      },
-      {
-        input: ['a'],
-        expected: [['a']],
-      },
-    ]
-    test.each(testCases)('$input $expected', ({ input, expected }) => {
-      const permutations = generatePermutations(input)
-      expect(permutations).toEqual(expected)
-    })
-  })
-
-  describe('generatePartialCombinations', () => {
-    const testCases = [
-      {
-        input: ['a', 'b', 'c'],
-        minLength: 2,
-        expected: [
-          ['a', 'b'],
-          ['a', 'c'],
-          ['b', 'c'],
-          ['a', 'b', 'c'],
-        ],
-      },
-      {
-        input: ['a', 'b'],
-        expected: [['a', 'b']],
-        minLength: 2,
-      },
-      {
-        input: ['a'],
-        expected: [],
-        minLength: 2,
-      },
-      {
-        input: ['a'],
-        expected: [['a']],
-        minLength: 1,
-      },
-      {
-        input: ['a'],
-        expected: [[], ['a']],
-        minLength: 0,
-      },
-    ]
-    test.each(testCases)(
-      '$input $minLength $expected',
-      ({ input, minLength, expected }) => {
-        const combinations = generatePartialCombinations(input, minLength)
-        expectArrayEqualIgnoreOrder(combinations, expected)
-      },
-    )
-  })
-
-  describe('generateInterleavedCombinations', () => {
-    const testCases = [
-      {
-        data: ['a', 'b'],
-        additional: ['x'],
-        expected: [
-          ['a', 'b'],
-          ['x', 'a', 'b'],
-          ['a', 'x', 'b'],
-          ['a', 'b', 'x'],
-        ],
-      },
-    ]
-    test.each(testCases)(
-      '$input $expected',
-      ({ data, additional, expected }) => {
-        const combinations = generateInterleavedCombinations(data, additional)
-        expectArrayEqualIgnoreOrder(combinations, expected)
-      },
-    )
-  })
-})

package/src/__tests__/test-utils.ts

@@ -1,108 +0,0 @@
-import { expect } from 'vitest'
-
-export function normalizeIndent(template: TemplateStringsArray) {
-  const codeLines = template[0]?.split('\n') ?? ['']
-  const leftPadding = codeLines[1]?.match(/\s+/)?.[0] ?? ''
-  return codeLines.map((line) => line.slice(leftPadding.length)).join('\n')
-}
-
-export function generatePermutations<T>(arr: Array<T>): Array<Array<T>> {
-  if (arr.length <= 1) {
-    return [arr]
-  }
-
-  const result: Array<Array<T>> = []
-  for (let i = 0; i < arr.length; i++) {
-    const rest = arr.slice(0, i).concat(arr.slice(i + 1))
-    const restPermutations = generatePermutations(rest)
-    for (const perm of restPermutations) {
-      result.push([arr[i]!, ...perm])
-    }
-  }
-
-  return result
-}
-
-export function generatePartialCombinations<T>(
-  arr: ReadonlyArray<T>,
-  minLength: number,
-): Array<Array<T>> {
-  const result: Array<Array<T>> = []
-
-  function backtrack(start: number, current: Array<T>) {
-    if (current.length > minLength - 1) {
-      result.push([...current])
-    }
-    for (let i = start; i < arr.length; i++) {
-      current.push(arr[i]!)
-      backtrack(i + 1, current)
-      current.pop()
-    }
-  }
-  backtrack(0, [])
-  return result
-}
-
-export function expectArrayEqualIgnoreOrder<T>(a: Array<T>, b: Array<T>) {
-  expect([...a].sort()).toEqual([...b].sort())
-}
-
-export function generateInterleavedCombinations<
-  TData,
-  TAdditional,
-  TResult extends TData | TAdditional,
->(
-  data: Array<TData> | ReadonlyArray<TData>,
-  additional: Array<TAdditional> | ReadonlyArray<TAdditional>,
-): Array<Array<TResult>> {
-  const result: Array<Array<TResult>> = []
-
-  function getSubsets(array: Array<TAdditional>): Array<Array<TAdditional>> {
-    return array.reduce(
-      (subsets, value) => {
-        return subsets.concat(subsets.map((set) => [...set, value]))
-      },
-      [[]] as Array<Array<TAdditional>>,
-    )
-  }
-
-  function insertAtPositions(
-    baseData: Array<TResult>,
-    subset: Array<TResult>,
-  ): Array<Array<TResult>> {
-    const combinations: Array<Array<TResult>> = []
-
-    const recurse = (
-      currentData: Array<TResult>,
-      currentSubset: Array<TResult>,
-      start: number,
-    ): void => {
-      if (currentSubset.length === 0) {
-        combinations.push([...currentData])
-        return
-      }
-
-      for (let i = start; i <= currentData.length; i++) {
-        const newData = [
-          ...currentData.slice(0, i),
-          currentSubset[0]!,
-          ...currentData.slice(i),
-        ]
-        recurse(newData, currentSubset.slice(1), i + 1)
-      }
-    }
-
-    recurse(baseData, subset, 0)
-    return combinations
-  }
-
-  const subsets = getSubsets(additional as Array<TAdditional>)
-
-  subsets.forEach((subset) => {
-    result.push(
-      ...insertAtPositions(data as Array<TResult>, subset as Array<TResult>),
-    )
-  })
-
-  return result
-}