@liberfi.io/hooks 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,349 @@
+import * as react from 'react';
+import react__default, { PropsWithChildren, RefObject, useLayoutEffect } from 'react';
+import { API, Chain, Token, TokenResolution, TokenCandle, TokenHolder, TokenMarketData, TokenSecurity, TokenStats, TradeActivity, WalletPortfolios } from '@liberfi.io/types';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
+import * as _liberfi_io_core from '@liberfi.io/core';
+import { WalletAdapter, EventEmitter, SimpleDI } from '@liberfi.io/core';
+export { default as useConstant } from 'use-constant';
+export * from 'use-debounce';
+
+declare global {
+    interface Window {
+        __LIBERFI_VERSION__?: {
+            [key: string]: string;
+        };
+    }
+}
+declare const _default: "0.1.0";
+
+interface APIClientContextValue {
+    client: API.IClient;
+    subscribeClient: API.ISubscribeClient;
+}
+declare const APIClientContext: react.Context<APIClientContextValue>;
+
+type APIClientProviderProps = PropsWithChildren<APIClientContextValue>;
+declare function APIClientProvider({ client, subscribeClient, children, }: APIClientProviderProps): react_jsx_runtime.JSX.Element;
+
+declare function useAPIClient(): APIClientContextValue;
+
+interface UseFinalStretchTokensQueryParams extends API.GetTokenListOptions {
+    chain: Chain;
+}
+declare function finalStretchTokensQueryKey(params: UseFinalStretchTokensQueryParams): string[];
+declare function fetchFinalStretchTokens(client: API.IClient, { chain, ...options }: UseFinalStretchTokensQueryParams): Promise<Token[]>;
+declare function useFinalStretchTokensQuery(params: UseFinalStretchTokensQueryParams, options?: Omit<UseQueryOptions<Array<Token>, Error, Array<Token>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Token[], Error>;
+
+interface UseMigratedTokensQueryParams extends API.GetTokenListOptions {
+    chain: Chain;
+}
+declare function migratedTokensQueryKey(params: UseMigratedTokensQueryParams): string[];
+declare function fetchMigratedTokens(client: API.IClient, { chain, ...options }: UseMigratedTokensQueryParams): Promise<Token[]>;
+declare function useMigratedTokensQuery(params: UseMigratedTokensQueryParams, options?: Omit<UseQueryOptions<Array<Token>, Error, Array<Token>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Token[], Error>;
+
+interface UseNewTokensQueryParams extends API.GetTokenListOptions {
+    chain: Chain;
+}
+declare function newTokensQueryKey(params: UseNewTokensQueryParams): string[];
+declare function fetchNewTokens(client: API.IClient, { chain, ...options }: UseNewTokensQueryParams): Promise<Token[]>;
+declare function useNewTokensQuery(params: UseNewTokensQueryParams, options?: Omit<UseQueryOptions<Array<Token>, Error, Array<Token>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Token[], Error>;
+
+declare function fetchPresignedUploadUrl(client: API.IClient): Promise<string>;
+declare function usePresignedUploadUrlQuery(options?: Omit<UseQueryOptions<string, Error, string, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<string, Error>;
+
+type UseSearchTokensQueryParams = API.SearchTokensOptions;
+declare function searchTokensQueryKey(params: UseSearchTokensQueryParams): string[];
+declare function fetchSearchTokens(client: API.IClient, params: UseSearchTokensQueryParams): Promise<API.SearchTokenCursorList>;
+declare function useSearchTokensQuery(params: UseSearchTokensQueryParams, options?: Omit<UseQueryOptions<API.SearchTokenCursorList, Error, API.SearchTokenCursorList, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<API.SearchTokenCursorList, Error>;
+
+type UseSendTxMutationParams = API.SendTxParams;
+declare function sendTx(client: API.IClient, params: UseSendTxMutationParams): Promise<API.SendTxResult>;
+declare function useSendTxMutation(options?: Omit<UseMutationOptions<API.SendTxResult, Error, UseSendTxMutationParams>, "mutationFn">): _tanstack_react_query.UseMutationResult<API.SendTxResult, Error, API.SendTxParams, unknown>;
+
+interface UseStockTokensQueryParams extends API.GetTokenListOptions {
+    chain: Chain;
+}
+declare function stockTokensQueryKey(params: UseStockTokensQueryParams): string[];
+declare function fetchStockTokens(client: API.IClient, { chain, ...options }: UseStockTokensQueryParams): Promise<Token[]>;
+declare function useStockTokensQuery(params: UseStockTokensQueryParams, options?: Omit<UseQueryOptions<Array<Token>, Error, Array<Token>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Token[], Error>;
+
+type UseSwapRouteQueryParams = API.SwapParams;
+declare function swapRouteQueryKey(params: UseSwapRouteQueryParams): string[];
+declare function fetchSwapRoute(client: API.IClient, params: UseSwapRouteQueryParams): Promise<API.SwapRoute>;
+declare function useSwapRouteQuery(params: UseSwapRouteQueryParams, options?: Omit<UseQueryOptions<API.SwapRoute, Error, API.SwapRoute, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<API.SwapRoute, Error>;
+
+interface UseTokenCandlesQueryParams extends API.GetTokenCandlesOptions {
+    chain: Chain;
+    address: string;
+    resolution: TokenResolution;
+}
+declare function tokenCandlesQueryKey(params: UseTokenCandlesQueryParams): string[];
+declare function fetchTokenCandles(client: API.IClient, { chain, address, resolution, ...options }: UseTokenCandlesQueryParams): Promise<TokenCandle[]>;
+declare function useTokenCandlesQuery(params: UseTokenCandlesQueryParams, options?: Omit<UseQueryOptions<Array<TokenCandle>, Error, Array<TokenCandle>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<TokenCandle[], Error>;
+
+interface UseTokenHoldersQueryParams extends API.CursorListOptions {
+    chain: Chain;
+    address: string;
+}
+declare function tokenHoldersQueryKey(params: UseTokenHoldersQueryParams): string[];
+declare function fetchTokenHolders(client: API.IClient, { chain, address, ...options }: UseTokenHoldersQueryParams): Promise<API.CursorList<TokenHolder>>;
+declare function useTokenHoldersQuery(params: UseTokenHoldersQueryParams, options?: Omit<UseQueryOptions<API.CursorList<TokenHolder>, Error, API.CursorList<TokenHolder>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<API.CursorList<TokenHolder>, Error>;
+
+interface UseTokenMarketDataQueryParams {
+    chain: Chain;
+    address: string;
+}
+declare function tokenMarketDataQueryKey(params: UseTokenMarketDataQueryParams): string[];
+declare function fetchTokenMarketData(client: API.IClient, { chain, address }: UseTokenMarketDataQueryParams): Promise<TokenMarketData>;
+declare function useTokenMarketDataQuery(params: UseTokenMarketDataQueryParams, options?: Omit<UseQueryOptions<TokenMarketData, Error, TokenMarketData, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<TokenMarketData, Error>;
+
+interface UseTokenQueryParams {
+    chain: Chain;
+    address: string;
+}
+declare function tokenQueryKey(params: UseTokenQueryParams): string[];
+declare function fetchToken(client: API.IClient, { chain, address }: UseTokenQueryParams): Promise<Token>;
+declare function useTokenQuery(params: UseTokenQueryParams, options?: Omit<UseQueryOptions<Token, Error, Token, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Token, Error>;
+
+interface UseTokenSecurityQueryParams {
+    chain: Chain;
+    address: string;
+}
+declare function tokenSecurityQueryKey(params: UseTokenSecurityQueryParams): string[];
+declare function fetchTokenSecurity(client: API.IClient, { chain, address }: UseTokenSecurityQueryParams): Promise<TokenSecurity>;
+declare function useTokenSecurityQuery(params: UseTokenSecurityQueryParams, options?: Omit<UseQueryOptions<TokenSecurity, Error, TokenSecurity, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<TokenSecurity, Error>;
+
+interface UseTokensQueryParams {
+    chain: Chain;
+    addresses: Array<string>;
+}
+declare function tokensQueryKey(params: UseTokensQueryParams): string[];
+declare function fetchTokens(client: API.IClient, { chain, addresses }: UseTokensQueryParams): Promise<Token[]>;
+declare function useTokensQuery(params: UseTokensQueryParams, options?: Omit<UseQueryOptions<Array<Token>, Error, Array<Token>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Token[], Error>;
+
+interface UseTokenStatsQueryParams {
+    chain: Chain;
+    address: string;
+}
+declare function tokenStatsQueryKey(params: UseTokenStatsQueryParams): string[];
+declare function fetchTokenStats(client: API.IClient, { chain, address }: UseTokenStatsQueryParams): Promise<TokenStats>;
+declare function useTokenStatsQuery(params: UseTokenStatsQueryParams, options?: Omit<UseQueryOptions<TokenStats, Error, TokenStats, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<TokenStats, Error>;
+
+interface UseTokenTradeActivitiesQueryParams extends API.GetTradeActivitiesOptions {
+    chain: Chain;
+    address: string;
+}
+declare function tokenTradeActivitiesQueryKey(params: UseTokenTradeActivitiesQueryParams): string[];
+declare function fetchTokenTradeActivities(client: API.IClient, { chain, address, ...options }: UseTokenTradeActivitiesQueryParams): Promise<API.CursorList<TradeActivity>>;
+declare function useTokenTradeActivitiesQuery(params: UseTokenTradeActivitiesQueryParams, options?: Omit<UseQueryOptions<API.CursorList<TradeActivity>, Error, API.CursorList<TradeActivity>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<API.CursorList<TradeActivity>, Error>;
+
+interface UseTrendingTokensQueryParams extends API.GetTokenListOptions {
+    chain: Chain;
+    resolution: "1m" | "5m" | "1h" | "4h" | "24h";
+}
+declare function trendingTokensQueryKey(params: UseTrendingTokensQueryParams): string[];
+declare function fetchTrendingTokens(client: API.IClient, { chain, resolution, ...options }: UseTrendingTokensQueryParams): Promise<Token[]>;
+declare function useTrendingTokensQuery(params: UseTrendingTokensQueryParams, options?: Omit<UseQueryOptions<Array<Token>, Error, Array<Token>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Token[], Error>;
+
+interface UseTxSuccessQueryParams {
+    chain: Chain;
+    txHash: string;
+    timeout?: number;
+}
+declare function txSuccessQueryKey(params: UseTxSuccessQueryParams): string[];
+declare function fetchTxSuccess(client: API.IClient, { chain, txHash, timeout }: UseTxSuccessQueryParams): Promise<boolean>;
+declare function useTxSuccessQuery(params: UseTxSuccessQueryParams, options?: Omit<UseQueryOptions<boolean, Error, boolean, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<boolean, Error>;
+
+interface UseWalletPortfoliosQueryParams {
+    chain: Chain;
+    address: string;
+}
+declare function walletPortfoliosQueryKey(params: UseWalletPortfoliosQueryParams): string[];
+declare function fetchWalletPortfolios(client: API.IClient, { chain, address }: UseWalletPortfoliosQueryParams): Promise<WalletPortfolios>;
+declare function useWalletPortfoliosQuery(params: UseWalletPortfoliosQueryParams, options?: Omit<UseQueryOptions<WalletPortfolios, Error, WalletPortfolios, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<WalletPortfolios, Error>;
+
+interface UseWalletTradeActivitiesQueryParams extends API.GetTradeActivitiesOptions {
+    chain: Chain;
+    address: string;
+}
+declare function walletTradeActivitiesQueryKey(params: UseWalletTradeActivitiesQueryParams): string[];
+declare function fetchWalletTradeActivities(client: API.IClient, { chain, address, ...options }: UseWalletTradeActivitiesQueryParams): Promise<API.CursorList<TradeActivity>>;
+declare function useWalletTradeActivitiesQuery(params: UseWalletTradeActivitiesQueryParams, options?: Omit<UseQueryOptions<API.CursorList<TradeActivity>, Error, API.CursorList<TradeActivity>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<API.CursorList<TradeActivity>, Error>;
+
+interface WalletConnectorContextValue {
+    /**
+     * detecting: is detecting connected wallets
+     * connecting: is connecting to the first wallet
+     * connected: is connected to at least one wallet
+     * disconnecting: is disconnecting from the last connected wallet
+     * disconnected: is disconnected from all wallets
+     */
+    status: "detecting" | "connecting" | "connected" | "disconnecting" | "disconnected";
+    wallets: Array<WalletAdapter>;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+}
+declare const WalletConnectorContext: react.Context<WalletConnectorContextValue>;
+
+/**
+ * use wallet connector hook
+ * @returns wallet connector
+ */
+declare function useWalletConnector(): WalletConnectorContextValue;
+
+/**
+ * use wallets hook
+ * @returns all wallets that can be used to take onchain actions
+ */
+declare function useWallets(): _liberfi_io_core.WalletAdapter[];
+
+type WalletConnectorProviderProps = PropsWithChildren<WalletConnectorContextValue>;
+declare function WalletConnectorProvider({ children, ...value }: WalletConnectorProviderProps): react_jsx_runtime.JSX.Element;
+
+type UseBooleanReturn = [
+    /** current state */
+    boolean,
+    {
+        /** set state to true */
+        setTrue: () => void;
+        /** set state to false */
+        setFalse: () => void;
+        /** toggle state */
+        toggle: () => void;
+    }
+];
+/**
+ * Hook to manage a boolean state
+ * @param initialValue Initial value of the boolean
+ * @returns
+ */
+declare const useBoolean: (initialValue?: boolean) => UseBooleanReturn;
+
+/**
+ * React hook to persist any value between renders,
+ * but keeps it up-to-date if it changes.
+ * @param fn the function to persist
+ * @param deps the function dependency list
+ */
+declare function useCallbackRef<T extends (...args: any[]) => any>(fn: T | undefined, deps?: React.DependencyList): T;
+
+/**
+ * Custom hook that determines if the component is currently mounted.
+ * @example
+ * ```tsx
+ * const isComponentMounted = useIsMounted();
+ * // Use isComponentMounted() to check if the component is currently mounted before performing certain actions.
+ * ```
+ */
+declare function useIsMounted(): () => boolean;
+
+/** The size of the observed element. */
+type Size = {
+    /** The width of the observed element. */
+    width: number | undefined;
+    /** The height of the observed element. */
+    height: number | undefined;
+};
+/** The options for the ResizeObserver. */
+type UseResizeObserverOptions<T extends HTMLElement = HTMLElement> = {
+    /** The ref of the element to observe. */
+    ref: RefObject<T | null>;
+    /**
+     * When using `onResize`, the hook doesn't re-render on element size changes; it delegates handling to the provided callback.
+     * @default undefined
+     */
+    onResize?: (size: Size) => void;
+    /**
+     * The box model to use for the ResizeObserver.
+     * @default 'content-box'
+     */
+    box?: "border-box" | "content-box" | "device-pixel-content-box";
+};
+/**
+ * Custom hook that observes the size of an element using the [`ResizeObserver API`](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver).
+ * @template T - The type of the element to observe.
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-resize-observer)
+ * @example
+ * ```tsx
+ * const myRef = useRef(null);
+ * const { width = 0, height = 0 } = useResizeObserver({
+ *   ref: myRef,
+ *   box: 'content-box',
+ * });
+ *
+ * <div ref={myRef}>Hello, world!</div>
+ * ```
+ */
+declare function useResizeObserver<T extends HTMLElement = HTMLElement>(options: UseResizeObserverOptions<T>): Size;
+
+declare const useSafeLayoutEffect: typeof useLayoutEffect;
+
+type TickEvent = {
+    /** delta time in milliseconds since last tick */
+    delta: number;
+    /** current timestamp in milliseconds */
+    now: number;
+};
+type TickCallback = (event: TickEvent) => void;
+type UnsubscribeTick = () => void;
+/**
+ * Hook to call a callback at specified interval
+ * @param callback Function to call at specified interval
+ * @param interval Interval in milliseconds (default: 1000ms)
+ * @returns
+ */
+declare function useTick(callback: TickCallback, interval?: number): void;
+
+/**
+ * Hook to get the age in milliseconds since birthday in every tick
+ * @param birthday Timestamp in milliseconds or Date object (default: now)
+ * @param interval Tick interval in milliseconds (default: 1000ms)
+ * @returns age in milliseconds since birthday
+ */
+declare function useTickAge(birthday?: number | Date, interval?: number): number;
+
+type NotFunction<T> = T extends (...args: any[]) => any ? never : T;
+declare const useUpdatedRef: <T>(val: NotFunction<T>) => react.RefObject<T>;
+
+type noop = (this: any, ...args: any[]) => any;
+type PickFunction<T extends noop> = (this: ThisParameterType<T>, ...args: Parameters<T>) => ReturnType<T>;
+declare const useMemoizedFn: <T extends noop>(fn: T) => PickFunction<T>;
+
+interface AudioPlayerOptions {
+    volume?: number;
+    loop?: boolean;
+    autoPlay?: boolean;
+}
+declare const useAudioPlayer: (src: string, options?: AudioPlayerOptions) => readonly [react__default.DetailedReactHTMLElement<{
+    controls: boolean;
+    ref: react__default.RefObject<HTMLAudioElement | null>;
+    autoPlay: boolean | undefined;
+    src: string;
+    style: {
+        display: "none";
+    };
+    onPlay: () => void;
+    onPlaying: () => void;
+    onPause: () => void;
+    onEnded: () => void;
+    onError: () => void;
+}, HTMLAudioElement>, react__default.RefObject<HTMLAudioElement | null>, "error" | "paused" | "idle" | "play" | "playing" | "ended"];
+
+declare const useEventEmitter: () => EventEmitter<string | symbol, any>;
+
+declare function useSessionStorage<T>(key: string, initialValue: T): [T, (data: any) => void];
+
+declare function parseJSON<T>(value: string | null): T | undefined;
+
+declare function useLocalStorage<T>(key: string, initialValue: T, options?: {
+    parseJSON: typeof parseJSON;
+}): [any, (value: T) => void];
+
+declare const useSimpleDI: <T>() => {
+    get: (name: string) => T;
+    register: typeof SimpleDI.register;
+};
+
+export { APIClientContext, type APIClientContextValue, APIClientProvider, type APIClientProviderProps, type TickCallback, type TickEvent, type UnsubscribeTick, type UseBooleanReturn, type UseFinalStretchTokensQueryParams, type UseMigratedTokensQueryParams, type UseNewTokensQueryParams, type UseResizeObserverOptions, type UseSearchTokensQueryParams, type UseSendTxMutationParams, type UseStockTokensQueryParams, type UseSwapRouteQueryParams, type UseTokenCandlesQueryParams, type UseTokenHoldersQueryParams, type UseTokenMarketDataQueryParams, type UseTokenQueryParams, type UseTokenSecurityQueryParams, type UseTokenStatsQueryParams, type UseTokenTradeActivitiesQueryParams, type UseTokensQueryParams, type UseTrendingTokensQueryParams, type UseTxSuccessQueryParams, type UseWalletPortfoliosQueryParams, type UseWalletTradeActivitiesQueryParams, WalletConnectorContext, type WalletConnectorContextValue, WalletConnectorProvider, type WalletConnectorProviderProps, fetchFinalStretchTokens, fetchMigratedTokens, fetchNewTokens, fetchPresignedUploadUrl, fetchSearchTokens, fetchStockTokens, fetchSwapRoute, fetchToken, fetchTokenCandles, fetchTokenHolders, fetchTokenMarketData, fetchTokenSecurity, fetchTokenStats, fetchTokenTradeActivities, fetchTokens, fetchTrendingTokens, fetchTxSuccess, fetchWalletPortfolios, fetchWalletTradeActivities, finalStretchTokensQueryKey, migratedTokensQueryKey, newTokensQueryKey, parseJSON, searchTokensQueryKey, sendTx, stockTokensQueryKey, swapRouteQueryKey, tokenCandlesQueryKey, tokenHoldersQueryKey, tokenMarketDataQueryKey, tokenQueryKey, tokenSecurityQueryKey, tokenStatsQueryKey, tokenTradeActivitiesQueryKey, tokensQueryKey, trendingTokensQueryKey, txSuccessQueryKey, useAPIClient, useAudioPlayer, useBoolean, useCallbackRef, useEventEmitter, useFinalStretchTokensQuery, useIsMounted, useLocalStorage, useMemoizedFn, useMigratedTokensQuery, useNewTokensQuery, usePresignedUploadUrlQuery, useResizeObserver, useSafeLayoutEffect, useSearchTokensQuery, useSendTxMutation, useSessionStorage, useSimpleDI, useStockTokensQuery, useSwapRouteQuery, useTick, useTickAge, useTokenCandlesQuery, useTokenHoldersQuery, useTokenMarketDataQuery, useTokenQuery, useTokenSecurityQuery, useTokenStatsQuery, useTokenTradeActivitiesQuery, useTokensQuery, useTrendingTokensQuery, useTxSuccessQuery, useUpdatedRef, useWalletConnector, useWalletPortfoliosQuery, useWalletTradeActivitiesQuery, useWallets, _default as version, walletPortfoliosQueryKey, walletTradeActivitiesQueryKey };