@mpen/routekit 0.1.0 → 0.1.1

package/src/client/headers.ts

@@ -1,31 +0,0 @@
-import type { MaybePromise } from './promise'
-
-type ClientHeadersInit = NonNullable<ConstructorParameters<typeof Headers>[0]>
-
-/**
- * Context passed to global header providers.
- *
- * @example
- * ```ts
- * const headers = (context: ClientHeaderContext) =>
- *     context.url.startsWith('/admin') ? { authorization: `Bearer ${token}` } : undefined
- * ```
- */
-export interface ClientHeaderContext {
-    /** The request URL before base URL resolution. */
-    url: string
-    /** The request init object before execution. */
-    init: RequestInit
-}
-
-/**
- * Headers or a function that provides headers for each request.
- *
- * @example
- * ```ts
- * const headers: ClientHeaders = () => ({ authorization: `Bearer ${token}` })
- * ```
- */
-export type ClientHeaders =
-    | ClientHeadersInit
-    | ((context: ClientHeaderContext) => MaybePromise<ClientHeadersInit | undefined>)

package/src/client/index.ts

@@ -1,8 +0,0 @@
-export * from './headers'
-export * from './promise'
-export * from './responses'
-export * from './transport'
-export * from './types'
-export * from './transports/body-codec'
-export * from './transports/fetch'
-export * from './url'

package/src/client/promise.ts

@@ -1,11 +0,0 @@
-/**
- * A value that may be returned immediately or through a promise.
- *
- * @example
- * ```ts
- * const headers: MaybePromise<HeadersInit> = { authorization: 'Bearer token' }
- * ```
- *
- * @typeParam T - The resolved value type.
- */
-export type MaybePromise<T> = T | Promise<T>

package/src/client/react/index.test.tsx

@@ -1,266 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-import { expectType, type TypeEqual } from '@mpen/ts-types'
-import { Window } from 'happy-dom'
-import type { ReactNode } from 'react'
-import type { ApiResponse } from '../responses'
-
-const testWindow = new Window({ url: 'http://localhost/' })
-
-testWindow.SyntaxError = SyntaxError
-
-Object.assign(globalThis, {
-    IS_REACT_ACT_ENVIRONMENT: true,
-    window: testWindow,
-    document: testWindow.document,
-    navigator: testWindow.navigator,
-    HTMLElement: testWindow.HTMLElement,
-    SyntaxError,
-})
-
-const { act } = await import('react')
-const { createRoot } = await import('react-dom/client')
-const { useQuery } = await import('./index')
-
-const roots: Array<ReturnType<typeof createRoot>> = []
-
-function render(children: ReactNode) {
-    const container = document.createElement('div')
-    document.body.append(container)
-
-    const root = createRoot(container)
-    roots.push(root)
-
-    act(() => {
-        root.render(children)
-    })
-
-    return { container, root }
-}
-
-function text(container: Element, testId: string): string | undefined {
-    return container.querySelector(`[data-testid="${testId}"]`)?.textContent ?? undefined
-}
-
-function waitFrame(): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, 0))
-}
-
-async function waitFor(assertion: () => void): Promise<void> {
-    let lastError: unknown
-
-    for (let attempt = 0; attempt < 30; attempt += 1) {
-        try {
-            assertion()
-            return
-        } catch (error) {
-            lastError = error
-        }
-
-        await act(async () => {
-            await waitFrame()
-        })
-    }
-
-    throw lastError
-}
-
-afterEach(() => {
-    for (const root of roots.splice(0)) {
-        act(() => {
-            root.unmount()
-        })
-    }
-
-    document.body.replaceChildren()
-})
-
-describe(useQuery.name, () => {
-    test('runs endpoint methods and refetches when arguments change', async () => {
-        type UserResponse = ApiResponse<{ enabled: boolean; id: number }>
-        const calls: Array<{ id: number; request: { body: boolean } }> = []
-        const endpoint = async (id: number, request: { body: boolean }): Promise<UserResponse> => {
-            calls.push({ id, request })
-            return {
-                ok: true,
-                status: 200,
-                headers: new Headers(),
-                body: { enabled: request.body, id },
-            }
-        }
-
-        function Reader({ id }: { id: number }) {
-            const query = useQuery(endpoint, id, { body: true })
-
-            expectType<TypeEqual<typeof query.data, { enabled: boolean; id: number } | undefined>>(
-                true,
-            )
-
-            return (
-                <span data-testid="state">{`${query.status}:${query.data?.id ?? 'none'}:${String(query.isFetching)}`}</span>
-            )
-        }
-
-        const { container, root } = render(<Reader id={1} />)
-
-        await waitFor(() => {
-            expect(text(container, 'state')).toBe('success:1:false')
-        })
-        expect(calls).toEqual([{ id: 1, request: { body: true } }])
-
-        act(() => {
-            root.render(<Reader id={1} />)
-        })
-
-        expect(calls).toHaveLength(1)
-
-        act(() => {
-            root.render(<Reader id={2} />)
-        })
-
-        await waitFor(() => {
-            expect(text(container, 'state')).toBe('success:2:false')
-        })
-        expect(calls).toEqual([
-            { id: 1, request: { body: true } },
-            { id: 2, request: { body: true } },
-        ])
-    })
-
-    test('supports options-first calls, selected data, and manual refetching', async () => {
-        type UserResponse = ApiResponse<{ id: number; label: string }>
-        const calls: number[] = []
-        const endpoint = async (id: number): Promise<UserResponse> => {
-            calls.push(id)
-            return {
-                ok: true,
-                status: 200,
-                headers: new Headers(),
-                body: { id, label: `user-${calls.length}` },
-            }
-        }
-        function Reader({ enabled }: { enabled: boolean }) {
-            const query = useQuery(
-                { enabled, select: (response) => response.body.label },
-                endpoint,
-                123,
-            )
-
-            expectType<TypeEqual<typeof query.data, string | undefined>>(true)
-
-            return (
-                <>
-                    <span data-testid="label">{`${query.status}:${query.data ?? 'none'}`}</span>
-                    <button type="button" onClick={() => void query.refetch()}>
-                        Refetch
-                    </button>
-                </>
-            )
-        }
-
-        const { container, root } = render(<Reader enabled={false} />)
-
-        expect(text(container, 'label')).toBe('idle:none')
-        expect(calls).toEqual([])
-
-        act(() => {
-            root.render(<Reader enabled />)
-        })
-
-        await waitFor(() => {
-            expect(text(container, 'label')).toBe('success:user-1')
-        })
-        expect(calls).toEqual([123])
-
-        act(() => {
-            container.querySelector('button')?.click()
-        })
-
-        await waitFor(() => {
-            expect(text(container, 'label')).toBe('success:user-2')
-        })
-        expect(calls).toEqual([123, 123])
-    })
-
-    test('keeps previous data by default while refetching', async () => {
-        type UserResponse = ApiResponse<{ id: number }>
-        let resolveSecond: ((response: UserResponse) => void) | undefined
-        const endpoint = (id: number): Promise<UserResponse> => {
-            if (id === 1) {
-                return Promise.resolve({
-                    ok: true,
-                    status: 200,
-                    headers: new Headers(),
-                    body: { id },
-                })
-            }
-
-            return new Promise((resolve) => {
-                resolveSecond = resolve
-            })
-        }
-
-        function Reader({ id }: { id: number }) {
-            const query = useQuery(endpoint, id)
-
-            return (
-                <span data-testid="state">{`${query.status}:${query.data?.id ?? 'none'}:${String(query.isFetching)}`}</span>
-            )
-        }
-
-        const { container, root } = render(<Reader id={1} />)
-
-        await waitFor(() => {
-            expect(text(container, 'state')).toBe('success:1:false')
-        })
-
-        act(() => {
-            root.render(<Reader id={2} />)
-        })
-
-        await waitFor(() => {
-            expect(text(container, 'state')).toBe('success:1:true')
-        })
-
-        await act(async () => {
-            resolveSecond?.({
-                ok: true,
-                status: 200,
-                headers: new Headers(),
-                body: { id: 2 },
-            })
-            await waitFrame()
-        })
-
-        await waitFor(() => {
-            expect(text(container, 'state')).toBe('success:2:false')
-        })
-    })
-
-    test('accepts generated-style endpoint properties with required object arguments', async () => {
-        type TodoResponse = ApiResponse<{ todos: string[] }>
-        const apiClient = {
-            todos: {
-                list: {
-                    get: async (query: { filter: 'all' | 'active' }): Promise<TodoResponse> => ({
-                        ok: true,
-                        status: 200,
-                        headers: new Headers(),
-                        body: { todos: [query.filter] },
-                    }),
-                },
-            },
-        }
-
-        function Reader() {
-            const query = useQuery({ enabled: false }, apiClient.todos.list.get, { filter: 'all' })
-
-            expectType<TypeEqual<typeof query.data, { todos: string[] } | undefined>>(true)
-
-            return <span data-testid="state">{query.status}</span>
-        }
-
-        const { container } = render(<Reader />)
-
-        expect(text(container, 'state')).toBe('idle')
-    })
-})