elhala-query/dist/index.d.mts

A lightweight, educational implementation of React Query concepts with Suspense support.

import * as react_jsx_runtime from 'react/jsx-runtime';
import { ReactNode } from 'react';

type QueryKey = ReadonlyArray<unknown>;
type MutationKey = ReadonlyArray<unknown>;
type QueryStatus = "idle" | "loading" | "success" | "error";
type MutationStatus = "idle" | "loading" | "success" | "error";
type QueryOptions<T> = {
    queryKey: QueryKey;
    queryFn: ({ queryKey }: {
        queryKey: QueryKey;
    }) => Promise<T>;
    cacheTime?: number;
};
type useQueryOptions<T> = QueryOptions<T> & {
    staleTime?: number;
};
type QueryState<T> = {
    data: T | undefined;
    error?: Error;
    isLoading: boolean;
    isFetching: boolean;
    isError: boolean;
    status: QueryStatus;
    lastUpdated: number | undefined;
    refetch: () => void;
};
type SuspenseQueryState<T> = QueryState<T> & {
    data: T;
    status: Exclude<QueryStatus, "loading">;
    error: undefined;
};
type Subcriber = {
    notify: () => void;
};
type Query<T> = {
    subscribers: Array<Subcriber>;
    state: QueryState<T>;
    options: QueryOptions<T> & {
        queryHash: string;
    };
    promise?: Promise<void>;
    gcTimeout?: ReturnType<typeof setTimeout>;
    subscribe: (subscriber: Subcriber) => () => void;
    setState: (updater: (state: QueryState<T>) => QueryState<T>) => void;
    fetch: () => Promise<void>;
    scheduleGC: () => void;
    unscheduleGC: () => void;
};
type QueryObserver<T> = {
    notify: () => void;
    getResults: () => QueryState<T>;
    subscribe: (callback: () => void) => () => void;
    fetch: () => void;
    fetchOptimistic: () => Promise<void>;
};
type MutationOptions<T> = {
    mutationFn: (variables?: unknown) => Promise<T>;
    mutationKey?: MutationKey;
    onSuccess?: (data: T) => void;
    onError?: (error: Error) => void;
    onSettled?: () => void;
    onMutate?: () => void;
};
type MutationState<T> = {
    data: T | undefined;
    error?: Error;
    isLoading: boolean;
    isSuccess: boolean;
    isError: boolean;
    status: QueryStatus;
    mutate: (variables?: unknown) => Promise<void>;
};
type Mutation<T> = {
    subscribers: Array<Subcriber>;
    state: MutationState<T>;
    options: MutationOptions<T> & {
        mutationHash: string;
    };
    subscribe: (subscriber: Subcriber) => () => void;
    setState: (updater: (state: MutationState<T>) => MutationState<T>) => void;
};
type MutationObserver<T> = {
    notify: () => void;
    getResults: () => MutationState<T>;
    subscribe: (callback: () => void) => () => void;
};

declare function useQuery<T>(options: useQueryOptions<T>): QueryState<T>;

declare function useMutation<T>(options: MutationOptions<T>): MutationState<T>;

declare class ElhalaClient {
    queries: Map<string, Query<any>>;
    mutations: Map<string, Mutation<any>>;
    constructor();
    getQuery<T>(options: QueryOptions<T>): Query<T>;
    getQueryData<T>(options: QueryOptions<T>): T | undefined;
    setQueryData<T>(options: QueryOptions<T>, data: T): void;
    removeQuery(query: Query<any>): void;
    invalidateQueries({ queryKey }: {
        queryKey: QueryKey;
    }): void;
    clearQueriesCache(): void;
    getMutation<T>(options: MutationOptions<T>): Mutation<T>;
    clearMutationsCache(): void;
}

declare const useElhalaClient: () => ElhalaClient;
declare const ElhalaProvider: ({ client, children, }: {
    client: ElhalaClient;
    children: ReactNode;
}) => react_jsx_runtime.JSX.Element;

declare function useSuspenseQuery<T>(options: useQueryOptions<T>): SuspenseQueryState<T>;

export { ElhalaClient, ElhalaProvider, type MutationKey, type MutationObserver, type MutationOptions, type MutationState, type MutationStatus, type QueryKey, type QueryObserver, type QueryOptions, type QueryState, type QueryStatus, useElhalaClient, useMutation, useQuery, type useQueryOptions, useSuspenseQuery };