From 95ca3e1338868f8db62077149814ac4eca0318b6 Mon Sep 17 00:00:00 2001
From: Wonsuk Choi <sukvvon@gmail.com>
Date: Thu, 1 Oct 2026 01:12:29 +0900
Subject: [PATCH] test(lit-query/createInfiniteQueryController): add type tests

---
 .../createInfiniteQueryController.test-d.ts   | 177 ++++++++++++++++++
 1 file changed, 177 insertions(+)
 create mode 100644 packages/lit-query/src/__tests__/createInfiniteQueryController.test-d.ts

diff --git a/packages/lit-query/src/__tests__/createInfiniteQueryController.test-d.ts b/packages/lit-query/src/__tests__/createInfiniteQueryController.test-d.ts
new file mode 100644
index 0000000000..77077da95e
--- /dev/null
+++ b/packages/lit-query/src/__tests__/createInfiniteQueryController.test-d.ts
@@ -0,0 +1,177 @@
+import { QueryClient } from '@tanstack/query-core'
+import { queryKey } from '@tanstack/query-test-utils'
+import { LitElement } from 'lit'
+import { describe, expectTypeOf, it } from 'vitest'
+import { createInfiniteQueryController } from '../createInfiniteQueryController.js'
+import type { InfiniteData } from '@tanstack/query-core'
+import type { CreateInfiniteQueryOptions } from '../createInfiniteQueryController.js'
+
+class Host extends LitElement {}
+
+describe('pageParam', () => {
+  it('initialPageParam should define type of param passed to queryFunctionContext', () => {
+    createInfiniteQueryController(
+      new Host(),
+      {
+        queryKey: queryKey(),
+        queryFn: ({ pageParam }) => {
+          expectTypeOf(pageParam).toEqualTypeOf<number>()
+        },
+        initialPageParam: 1,
+        getNextPageParam: () => undefined,
+      },
+      new QueryClient(),
+    )
+  })
+
+  it('direction should be passed to queryFn of createInfiniteQueryController', () => {
+    createInfiniteQueryController(
+      new Host(),
+      {
+        queryKey: queryKey(),
+        queryFn: ({ direction }) => {
+          expectTypeOf(direction).toEqualTypeOf<'forward' | 'backward'>()
+        },
+        initialPageParam: 1,
+        getNextPageParam: () => undefined,
+      },
+      new QueryClient(),
+    )
+  })
+})
+
+describe('select', () => {
+  it('should still return paginated data if no select result', () => {
+    const infiniteQuery = createInfiniteQueryController(
+      new Host(),
+      {
+        queryKey: queryKey(),
+        queryFn: ({ pageParam }) => {
+          return pageParam * 5
+        },
+        initialPageParam: 1,
+        getNextPageParam: () => undefined,
+      },
+      new QueryClient(),
+    )
+
+    // TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
+    expectTypeOf(infiniteQuery().data).toEqualTypeOf<
+      InfiniteData<number, unknown> | undefined
+    >()
+  })
+
+  it('should be able to transform data to arbitrary result', () => {
+    const infiniteQuery = createInfiniteQueryController(
+      new Host(),
+      {
+        queryKey: queryKey(),
+        queryFn: ({ pageParam }) => {
+          return pageParam * 5
+        },
+        initialPageParam: 1,
+        getNextPageParam: () => undefined,
+        select: (data) => {
+          expectTypeOf(data).toEqualTypeOf<InfiniteData<number, number>>()
+          return 'selected' as const
+        },
+      },
+      new QueryClient(),
+    )
+
+    expectTypeOf(infiniteQuery().data).toEqualTypeOf<'selected' | undefined>()
+  })
+})
+
+describe('getNextPageParam / getPreviousPageParam', () => {
+  it('should get typed params', () => {
+    const infiniteQuery = createInfiniteQueryController(
+      new Host(),
+      {
+        queryKey: queryKey(),
+        queryFn: ({ pageParam }) => {
+          return String(pageParam)
+        },
+        initialPageParam: 1,
+        getNextPageParam: (
+          lastPage,
+          allPages,
+          lastPageParam,
+          allPageParams,
+        ) => {
+          expectTypeOf(lastPage).toEqualTypeOf<string>()
+          expectTypeOf(allPages).toEqualTypeOf<Array<string>>()
+          expectTypeOf(lastPageParam).toEqualTypeOf<number>()
+          expectTypeOf(allPageParams).toEqualTypeOf<Array<number>>()
+          return undefined
+        },
+        getPreviousPageParam: (
+          firstPage,
+          allPages,
+          firstPageParam,
+          allPageParams,
+        ) => {
+          expectTypeOf(firstPage).toEqualTypeOf<string>()
+          expectTypeOf(allPages).toEqualTypeOf<Array<string>>()
+          expectTypeOf(firstPageParam).toEqualTypeOf<number>()
+          expectTypeOf(allPageParams).toEqualTypeOf<Array<number>>()
+          return undefined
+        },
+      },
+      new QueryClient(),
+    )
+
+    // TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
+    expectTypeOf(infiniteQuery().data).toEqualTypeOf<
+      InfiniteData<string, unknown> | undefined
+    >()
+  })
+})
+
+describe('error booleans', () => {
+  it('should not be permanently `false`', () => {
+    const infiniteQuery = createInfiniteQueryController(
+      new Host(),
+      {
+        queryKey: queryKey(),
+        queryFn: ({ pageParam }) => {
+          return pageParam * 5
+        },
+        initialPageParam: 1,
+        getNextPageParam: () => undefined,
+      },
+      new QueryClient(),
+    )
+    const {
+      isFetchNextPageError,
+      isFetchPreviousPageError,
+      isLoadingError,
+      isRefetchError,
+    } = infiniteQuery()
+
+    expectTypeOf(isFetchNextPageError).toEqualTypeOf<boolean>()
+    expectTypeOf(isFetchPreviousPageError).toEqualTypeOf<boolean>()
+    expectTypeOf(isLoadingError).toEqualTypeOf<boolean>()
+    expectTypeOf(isRefetchError).toEqualTypeOf<boolean>()
+  })
+})
+
+describe('CreateInfiniteQueryOptions', () => {
+  it('should default TData to InfiniteData<TQueryFnData>', () => {
+    const options: CreateInfiniteQueryOptions<number, Error> = {
+      queryKey: queryKey(),
+      queryFn: () => 5,
+      initialPageParam: 1,
+      getNextPageParam: () => undefined,
+    }
+    const infiniteQuery = createInfiniteQueryController(
+      new Host(),
+      options,
+      new QueryClient(),
+    )
+
+    expectTypeOf(infiniteQuery().data).toEqualTypeOf<
+      InfiniteData<number, unknown> | undefined
+    >()
+  })
+})