remix-client-cache/dist/index.d.cts

Utility library to cache your client data in React Router

import React from 'react';
import { ClientActionFunctionArgs, LoaderFunctionArgs } from 'react-router';

type ExtendedComponentProps<T> = CachedLoaderDataReturn & T;
declare const CacheRoute: (Component: (props: any) => JSX.Element, settings?: CachedLoaderDataProps) => (props: any) => React.JSX.Element;
interface CacheAdapter {
    getItem: (key: string) => any | Promise<any>;
    setItem: (key: string, value: any) => Promise<any> | any;
    removeItem: (key: string) => Promise<any> | any;
}
type Prettify<T> = {
    [K in keyof T]: T[K];
} & {};
declare let cache: CacheAdapter;
declare const createCacheAdapter: (adapter: () => CacheAdapter) => {
    adapter: undefined;
} | {
    adapter: CacheAdapter;
};
declare const configureGlobalCache: (newCacheInstance: () => CacheAdapter | Storage) => void;
declare const decacheClientLoader: ({ request, serverAction }: ClientActionFunctionArgs, { key, adapter, }: {
    key?: string;
    adapter?: CacheAdapter;
}) => Promise<unknown>;
type CacheClientLoaderArgs = {
    type?: "swr" | "normal";
    key?: string;
    adapter?: CacheAdapter;
};
declare const cacheClientLoader: <T extends ClientLoaderFunctionArgs, TServerLoaderReturn = Awaited<ReturnType<T["serverLoader"]>>>({ request, serverLoader }: ClientLoaderFunctionArgs, { type, key, adapter, }?: CacheClientLoaderArgs) => Promise<Prettify<TServerLoaderReturn & {
    serverData: TServerLoaderReturn;
    deferredServerData: Promise<TServerLoaderReturn> | undefined;
    key: string;
}>>;
interface ClientLoaderFunctionArgs extends LoaderFunctionArgs {
    serverLoader: () => unknown;
}
declare const createClientLoaderCache: <U extends ClientLoaderFunctionArgs>(props?: CacheClientLoaderArgs) => {
    (args: U): Promise<Awaited<ReturnType<U["serverLoader"]>> & {
        serverData: Awaited<ReturnType<U["serverLoader"]>>;
        deferredServerData: Promise<Awaited<ReturnType<U["serverLoader"]>>> | undefined;
        key: string;
    } extends infer T ? { [K in keyof T]: (Awaited<ReturnType<U["serverLoader"]>> & {
        serverData: Awaited<ReturnType<U["serverLoader"]>>;
        deferredServerData: Promise<Awaited<ReturnType<U["serverLoader"]>>> | undefined;
        key: string;
    })[K]; } : never>;
    hydrate: boolean;
};
interface CachedLoaderDataProps {
    adapter?: CacheAdapter;
}
interface CachedLoaderDataReturn {
    cacheKey?: string;
    invalidate: () => Promise<void>;
}
declare function useCachedLoaderData<T>({ adapter }?: CachedLoaderDataProps): T & CachedLoaderDataReturn;
declare const invalidateCache: (key: string | string[]) => Promise<void>;
declare const useCacheInvalidator: () => {
    invalidateCache: (key: string | string[]) => Promise<void>;
};
declare function useSwrData<T>({ serverData, deferredServerData, ...args }: any): ({ children, }: {
    children: (data: T) => React.ReactElement;
}) => React.JSX.Element;

export { CacheAdapter, CacheRoute, ExtendedComponentProps, cache, cacheClientLoader, configureGlobalCache, createCacheAdapter, createClientLoaderCache, decacheClientLoader, invalidateCache, useCacheInvalidator, useCachedLoaderData, useSwrData };