mizan/protocol/mizan-codegen/tests/fixtures/baselines/react/react.tsx

'use client'

// AUTO-GENERATED by mizan — do not edit

import {
    createContext,
    useCallback,
    useContext,
    useEffect,
    useRef,
    useState,
    useSyncExternalStore,
    type ReactNode,
} from 'react'
import {
    configure,
    initSession,
    mizanCall,
    mizanFetch,
    MizanError,
    registerContext,
    type ContextState,
} from '@mizan/base'

import { fetchUserContext, type UserContextData, type UserContextParams, callUpdateProfile, callEcho, callFindUser, callRenameUser, callWhoami, type userOrdersOutput, type userProfileOutput } from './index'

// Internal — runs inside a Provider, registers with the kernel exactly once.
function useContextSubscription<T>(
    name: string,
    params: Record<string, any>,
    fetchFn: () => Promise<T>,
    initialData?: T,
): ContextState<T> {
    const ref = useRef<ReturnType<typeof registerContext> | null>(null)
    if (!ref.current) {
        ref.current = registerContext(name, params, fetchFn, initialData)
    }
    const handle = ref.current

    useEffect(() => {
        if (handle.getState().status === 'idle') handle.refetch()
        return () => handle.unregister()
    }, [handle])

    return useSyncExternalStore(handle.subscribe, handle.getState, handle.getState)
}

// Internal — wraps an imperative call() with isPending / error state.
interface MutationHook<TArgs, TResult> {
    mutate: (args: TArgs) => Promise<TResult>
    isPending: boolean
    error: Error | null
}

function useMutation<TArgs, TResult>(
    callFn: (args: TArgs) => Promise<TResult>,
): MutationHook<TArgs, TResult> {
    const [isPending, setIsPending] = useState(false)
    const [error, setError] = useState<Error | null>(null)

    const mutate = useCallback(async (args: TArgs) => {
        setIsPending(true)
        setError(null)
        try {
            return await callFn(args)
        } catch (e) {
            setError(e as Error)
            throw e
        } finally {
            setIsPending(false)
        }
    }, [callFn])

    return { mutate, isPending, error }
}

// ── User Context ──

const UserCtx = createContext<ContextState<UserContextData> | null>(null)

export function UserContext({ children, ...params }: UserContextParams & { children: ReactNode }) {
    const state = useContextSubscription('user', params, () => fetchUserContext(params))
    return <UserCtx.Provider value={state}>{children}</UserCtx.Provider>
}

export function useUserContext(): ContextState<UserContextData> {
    const ctx = useContext(UserCtx)
    if (!ctx) throw new Error('useUserContext requires <UserContext>')
    return ctx
}

export function useUserOrders(): userOrdersOutput | null {
    return useUserContext().data?.user_orders ?? null
}

export function useUserProfile(): userProfileOutput | null {
    return useUserContext().data?.user_profile ?? null
}

export function useUpdateProfile() {
    return useMutation<Parameters<typeof callUpdateProfile>[0], Awaited<ReturnType<typeof callUpdateProfile>>>(callUpdateProfile)
}

export function useEcho() {
    return useMutation<Parameters<typeof callEcho>[0], Awaited<ReturnType<typeof callEcho>>>(callEcho)
}

export function useFindUser() {
    return useMutation<Parameters<typeof callFindUser>[0], Awaited<ReturnType<typeof callFindUser>>>(callFindUser)
}

export function useRenameUser() {
    return useMutation<Parameters<typeof callRenameUser>[0], Awaited<ReturnType<typeof callRenameUser>>>(callRenameUser)
}

export function useWhoami() {
    return useMutation<void, Awaited<ReturnType<typeof callWhoami>>>(() => callWhoami() as any)
}

// ── MizanContext root provider ──

export interface MizanContextProps {
    /** Base URL for protocol endpoints. Defaults to "/api/mizan". */
    baseUrl?: string
    /** Set to `false` for backends without a `/session/` endpoint (e.g. FastAPI). */
    session?: boolean
    children: ReactNode
}

/**
 * Root provider — calls configure() once and mounts the global context (if defined).
 * Must wrap any component using Mizan-generated hooks.
 */
export function MizanContext({ baseUrl, session, children }: MizanContextProps) {
    const configured = useRef(false)
    if (!configured.current) {
        const opts: Parameters<typeof configure>[0] = {}
        if (baseUrl !== undefined) opts.baseUrl = baseUrl
        if (session !== undefined) opts.session = session
        if (Object.keys(opts).length > 0) configure(opts)
        configured.current = true
    }
    return <>{children}</>
}

// ── Imperative escape hatch ──

/**
 * Returns the imperative kernel API. For test harnesses or rare cases where
 * a typed generated hook does not fit. Most app code should use the typed hooks.
 */
export function useMizan() {
    return { call: mizanCall, fetch: mizanFetch }
}

export type { ContextState } from '@mizan/base'
export { configure, initSession, MizanError } from '@mizan/base'