@dappql/react 1.0.1

package/dist/react/src/Mutation.js

@@ -0,0 +1,147 @@
+import { useCallback, useMemo } from 'react';
+import { useAccount, usePublicClient, useWaitForTransactionReceipt, useWriteContract } from 'wagmi';
+import { useDappQL } from './Context.js';
+function useSimulate(config, address, account, chain, client) {
+    return useCallback(async (...args) => {
+        if (!client)
+            throw new Error('No client');
+        return await client?.simulateContract({
+            abi: config.getAbi(),
+            functionName: config.functionName,
+            address,
+            args,
+            account,
+        });
+    }, [address, config, account, chain?.id, client]);
+}
+function useEstimate(config, address, account, chain, client) {
+    return useCallback(async (...args) => {
+        if (!client)
+            throw new Error('No client');
+        return await client?.estimateContractGas({
+            abi: config.getAbi(),
+            functionName: config.functionName,
+            address,
+            args,
+            account,
+        });
+    }, [address, config, account, chain?.id, client]);
+}
+function useMutationConfirmation(hash) {
+    return useWaitForTransactionReceipt({ hash });
+}
+/**
+ * Hook for executing contract write operations (mutations)
+ * @param config Configuration object containing contract details and ABI
+ * @param optionsOrTransactionName Optional configuration or transaction name
+ * @returns Object containing mutation state and send function
+ *
+ * @example
+ * const mutation = useMutation({
+ *   contractName: 'MyContract',
+ *   functionName: 'setValue',
+ *   getAbi: () => CONTRACT_ABI,
+ *   deployAddress: '0x...'
+ * }, 'Set Value')
+ *
+ * // Execute the mutation
+ * mutation.send(newValue)
+ */
+export function useMutation(config, optionsOrTransactionName) {
+    const { addressResolver, onMutationUpdate, simulateMutations } = useDappQL();
+    const { chain, address: account } = useAccount();
+    const tx = useWriteContract();
+    const client = usePublicClient();
+    const address = useMemo(() => optionsOrTransactionName && typeof optionsOrTransactionName !== 'string' && optionsOrTransactionName.address
+        ? optionsOrTransactionName.address
+        : addressResolver?.(config.contractName.toString()) || config.deployAddress, [config.contractName, addressResolver, JSON.stringify(optionsOrTransactionName)]);
+    const options = useMemo(() => typeof optionsOrTransactionName === 'string'
+        ? { transactionName: optionsOrTransactionName }
+        : optionsOrTransactionName, [optionsOrTransactionName]);
+    const mutationInfo = {
+        account,
+        address,
+        contractName: config.contractName,
+        functionName: config.functionName,
+        transactionName: options?.transactionName || '',
+    };
+    const simulate = useSimulate(config, address, account, chain, client);
+    const estimate = useEstimate(config, address, account, chain, client);
+    const send = useCallback((...args) => {
+        const now = Date.now();
+        const id = mutationInfo.address + mutationInfo.functionName + now.toString();
+        if (!account || !chain?.id) {
+            const error = !account ? 'No account connected' : 'Invalid chain';
+            onMutationUpdate?.({
+                ...mutationInfo,
+                error: new Error(error),
+                args,
+                id,
+                status: 'error',
+            });
+            return;
+        }
+        const sendTx = () => {
+            tx.writeContract({
+                abi: config.getAbi(),
+                functionName: config.functionName,
+                address,
+                chainId: chain?.id,
+                args,
+            }, {
+                onSettled(data, error) {
+                    const status = error ? 'error' : 'signed';
+                    onMutationUpdate?.({
+                        ...mutationInfo,
+                        id,
+                        args,
+                        error: error ? new Error(error.message) : undefined,
+                        status,
+                        txHash: data,
+                    });
+                },
+            });
+            onMutationUpdate?.({
+                ...mutationInfo,
+                id,
+                args,
+                status: 'submitted',
+            });
+        };
+        if ((options?.simulate ?? simulateMutations) && client) {
+            simulate(...args)
+                .then(sendTx)
+                .catch((error) => {
+                onMutationUpdate?.({
+                    ...mutationInfo,
+                    id,
+                    args,
+                    error: new Error(error.message),
+                    status: 'error',
+                });
+            });
+        }
+        else {
+            sendTx();
+        }
+    }, [address, tx, config, account, chain?.id, options?.simulate, simulateMutations, client, simulate]);
+    const confirmation = useMutationConfirmation(tx.data);
+    return useMemo(() => ({
+        status: tx.status,
+        data: tx.data,
+        error: tx.error,
+        isPending: tx.isPending,
+        isSuccess: tx.isSuccess,
+        isError: tx.isError,
+        isLoading: tx.isPending || confirmation.isLoading,
+        failureCount: tx.failureCount,
+        failureReason: tx.failureReason,
+        isIdle: tx.isIdle,
+        submittedAt: tx.submittedAt,
+        confirmation,
+        reset: tx.reset,
+        send,
+        simulate,
+        estimate,
+    }), [tx, send, confirmation, simulate, estimate]);
+}

package/dist/react/src/Provider.d.ts

@@ -0,0 +1,34 @@
+import { type ComponentType } from 'react';
+import { MutationCallbacks, AddressResolverFunction, AddressResolverProps, QueryContextProps } from '../../shared/types.js';
+export declare const ADDRESS_RESOLVER_ERROR = "Cannot provide both AddressResolverComponent and addressResolver. Please use only one of these props.";
+/**
+ * Props for the Provider component
+ */
+type BaseProviderProps = QueryContextProps & {
+    children: any;
+    /** Whether to simulate mutations before sending them */
+    simulateMutations?: boolean;
+} & MutationCallbacks;
+export type ProviderProps = BaseProviderProps & ({
+    /** Function to resolve contract addresses */
+    addressResolver: AddressResolverFunction;
+    /** Component to handle address resolution - cannot be used with addressResolver */
+    AddressResolverComponent?: never;
+} | {
+    /** Function to resolve contract addresses - cannot be used with AddressResolverComponent */
+    addressResolver?: never;
+    /** Component to handle address resolution */
+    AddressResolverComponent: ComponentType<AddressResolverProps>;
+} | {
+    /** Function to resolve contract addresses - optional if no resolution needed */
+    addressResolver?: never;
+    /** Component to handle address resolution - optional if no resolution needed */
+    AddressResolverComponent?: never;
+});
+/**
+ * Core provider component for DappQL
+ * Manages contract address resolution and mutation callbacks
+ */
+export declare function DappQLProvider({ children, AddressResolverComponent, blocksRefetchInterval, defaultBatchSize, watchBlocks, simulateMutations, addressResolver, onMutationUpdate, }: ProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=Provider.d.ts.map

package/dist/react/src/Provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.d.ts","sourceRoot":"","sources":["../../../src/Provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAqB,MAAM,OAAO,CAAA;AAI7D,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,oBAAoB,EACpB,iBAAiB,EAClB,MAAM,uBAAuB,CAAA;AAI9B,eAAO,MAAM,sBAAsB,0GACsE,CAAA;AAEzG;;GAEG;AACH,KAAK,iBAAiB,GAAG,iBAAiB,GAAG;IAC3C,QAAQ,EAAE,GAAG,CAAA;IACb,wDAAwD;IACxD,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B,GAAG,iBAAiB,CAAA;AAErB,MAAM,MAAM,aAAa,GAAG,iBAAiB,GAC3C,CACI;IACE,6CAA6C;IAC7C,eAAe,EAAE,uBAAuB,CAAA;IACxC,mFAAmF;IACnF,wBAAwB,CAAC,EAAE,KAAK,CAAA;CACjC,GACD;IACE,4FAA4F;IAC5F,eAAe,CAAC,EAAE,KAAK,CAAA;IACvB,6CAA6C;IAC7C,wBAAwB,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAAA;CAC9D,GACD;IACE,gFAAgF;IAChF,eAAe,CAAC,EAAE,KAAK,CAAA;IACvB,gFAAgF;IAChF,wBAAwB,CAAC,EAAE,KAAK,CAAA;CACjC,CACJ,CAAA;AAEH;;;GAGG;AACH,wBAAgB,cAAc,CAAC,EAC7B,QAAQ,EACR,wBAAwB,EACxB,qBAAyB,EACzB,gBAAuB,EACvB,WAAW,EACX,iBAAiB,EACjB,eAAe,EACf,gBAAgB,GACjB,EAAE,aAAa,2CA8Cf"}

package/dist/react/src/Provider.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from 'react';
+import { useBlockNumberSubscriber } from './blocksHandler.js';
+import useTransactionUpdates from './useTransactionUpdates.js';
+import { DappQLContext } from './Context.js';
+import { ContextQueryProvider } from './ContextQueryManager.js';
+export const ADDRESS_RESOLVER_ERROR = 'Cannot provide both AddressResolverComponent and addressResolver. Please use only one of these props.';
+/**
+ * Core provider component for DappQL
+ * Manages contract address resolution and mutation callbacks
+ */
+export function DappQLProvider({ children, AddressResolverComponent, blocksRefetchInterval = 1, defaultBatchSize = 1024, watchBlocks, simulateMutations, addressResolver, onMutationUpdate, }) {
+    if (AddressResolverComponent && addressResolver) {
+        throw new Error(ADDRESS_RESOLVER_ERROR);
+    }
+    const [addressResolverState, setAddressResolver] = useState({ resolver: addressResolver });
+    const onBlockChange = useBlockNumberSubscriber();
+    const handleMutationUpdate = useTransactionUpdates(onMutationUpdate);
+    const value = useMemo(() => ({
+        onBlockChange,
+        onMutationUpdate: handleMutationUpdate,
+        addressResolver: addressResolverState.resolver,
+        blocksRefetchInterval,
+        defaultBatchSize,
+        watchBlocks,
+        simulateMutations,
+    }), [
+        onBlockChange,
+        handleMutationUpdate,
+        addressResolverState.resolver,
+        blocksRefetchInterval,
+        defaultBatchSize,
+        watchBlocks,
+        simulateMutations,
+    ]);
+    return (_jsxs(DappQLContext.Provider, { value: value, children: [AddressResolverComponent ? (_jsx(AddressResolverComponent, { onResolved: (resolver) => {
+                    setAddressResolver({ resolver });
+                } })) : null, !AddressResolverComponent || addressResolverState.resolver ? (_jsx(ContextQueryProvider, { ...value, children: children })) : null] }));
+}

package/dist/react/src/Query.d.ts

@@ -0,0 +1,52 @@
+import { useReadContracts } from 'wagmi';
+import { GetItemCallFunction, QueryOptions, type Request, type RequestCollection } from '../../shared/types.js';
+import { IteratorQueryResult } from './queryHooks.js';
+/**
+ * React hook that executes multiple contract read calls in a single multicall
+ * @param requests Collection of contract requests to execute
+ * @param options Query configuration options
+ * @returns Object containing query results and status
+ * @example
+ * ```ts
+ * const { data, isLoading } = useQuery({
+ *   value1: contracts.myContract.getValue(1, 2, 3),
+ *   value2: contracts.myOtherContract.getOtherValue(4, 5, 6),
+ * })
+ * ```
+ */
+export declare function useQuery<T extends RequestCollection>(requests: T, options?: QueryOptions): Omit<ReturnType<typeof useReadContracts>, 'data'> & {
+    data: {
+        [K in keyof T]: NonNullable<T[K]['defaultValue']>;
+    };
+};
+/**
+ * React hook that executes a single contract read call
+ * This is a convenience wrapper around useQuery for when you only need to query one contract method
+ * @param request The contract request to execute
+ * @param options Query configuration options
+ * @returns Object containing the query result and status, with data directly accessible (not nested in an object)
+ * @example
+ * ```ts
+ * const { data, isLoading } = useSingleQuery(
+ *   contracts.myContract.getValue(1, 2, 3)
+ * )
+ * ```
+ */
+export declare function useSingleQuery<T extends Request>(request: T, options?: QueryOptions): Omit<ReturnType<typeof useQuery>, 'data'> & {
+    data: NonNullable<T['defaultValue']>;
+};
+/**
+ * React hook for querying iterable data structures (like arrays) from smart contracts
+ * @param total Total number of items to query
+ * @param getItem Function that generates the query for a specific index
+ * @param options Query configuration options including optional starting index
+ * @returns Object containing array of query results and status
+ * @example
+ * ```ts
+ * const { data, isLoading } = useIteratorQuery(10, (i) => contracts.myContract.getValue(i))
+ * ```
+ */
+export declare function useIteratorQuery<T>(total: bigint, getItem: GetItemCallFunction<T>, options?: QueryOptions & {
+    firstIndex?: bigint;
+}): IteratorQueryResult<T>;
+//# sourceMappingURL=Query.d.ts.map

package/dist/react/src/Query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Query.d.ts","sourceRoot":"","sources":["../../../src/Query.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAA;AAExC,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,KAAK,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAE/G,OAAO,EAAE,mBAAmB,EAAuD,MAAM,iBAAiB,CAAA;AAK1G;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,iBAAiB,EAClD,QAAQ,EAAE,CAAC,EACX,OAAO,GAAE,YAAiB,GACzB,IAAI,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAAE,MAAM,CAAC,GAAG;IACrD,IAAI,EAAE;SAAG,CAAC,IAAI,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC;KAAE,CAAA;CAC5D,CA0CA;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,OAAO,EAC9C,OAAO,EAAE,CAAC,EACV,OAAO,GAAE,YAAiB,GACzB,IAAI,CAAC,UAAU,CAAC,OAAO,QAAQ,CAAC,EAAE,MAAM,CAAC,GAAG;IAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAA;CAAE,CAMtF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAC/B,OAAO,GAAE,YAAY,GAAG;IACtB,UAAU,CAAC,EAAE,MAAM,CAAA;CACf,GACL,mBAAmB,CAAC,CAAC,CAAC,CAKxB"}

package/dist/react/src/Query.js

@@ -0,0 +1,92 @@
+import { useMemo } from 'react';
+import { useReadContracts } from 'wagmi';
+import { useDappQL, useRefetchOnBlockChange } from './Context.js';
+import { useDefaultData, useIteratorQueryData, useResultData } from './queryHooks.js';
+import { useCallKeys } from './queryHooks.js';
+import { useRequestString } from './queryHooks.js';
+import { buildIteratorQuery } from './buildIteratorQuery.js';
+/**
+ * React hook that executes multiple contract read calls in a single multicall
+ * @param requests Collection of contract requests to execute
+ * @param options Query configuration options
+ * @returns Object containing query results and status
+ * @example
+ * ```ts
+ * const { data, isLoading } = useQuery({
+ *   value1: contracts.myContract.getValue(1, 2, 3),
+ *   value2: contracts.myOtherContract.getOtherValue(4, 5, 6),
+ * })
+ * ```
+ */
+export function useQuery(requests, options = {}) {
+    const { addressResolver, blocksRefetchInterval, defaultBatchSize, watchBlocks } = useDappQL();
+    const requestString = useRequestString(requests);
+    const callKeys = useCallKeys(requests, requestString);
+    const calls = useMemo(() => {
+        return Object.values(requests).map((req) => {
+            return {
+                abi: req.getAbi(),
+                functionName: req.method,
+                args: req.args,
+                address: req.address || addressResolver?.(req.contractName) || req.deployAddress,
+                chainId: req.chainId,
+            };
+        });
+    }, [requestString]);
+    const defaultData = useDefaultData(requests, callKeys);
+    const result = useReadContracts({
+        blockNumber: options.blockNumber,
+        query: {
+            enabled: !options.paused,
+            refetchInterval: options.refetchInterval,
+            notifyOnChangeProps: ['data', 'error'],
+        },
+        contracts: calls,
+        batchSize: options.batchSize ?? defaultBatchSize,
+    });
+    const data = useResultData(requests, callKeys, result, defaultData);
+    useRefetchOnBlockChange(result.refetch, (options.watchBlocks ?? watchBlocks) &&
+        !options.paused &&
+        !options.isStatic &&
+        !options.blockNumber &&
+        !options.refetchInterval, options.blocksRefetchInterval ?? blocksRefetchInterval);
+    return useMemo(() => {
+        return { ...result, data };
+    }, [result.error, result.isLoading, data]);
+}
+/**
+ * React hook that executes a single contract read call
+ * This is a convenience wrapper around useQuery for when you only need to query one contract method
+ * @param request The contract request to execute
+ * @param options Query configuration options
+ * @returns Object containing the query result and status, with data directly accessible (not nested in an object)
+ * @example
+ * ```ts
+ * const { data, isLoading } = useSingleQuery(
+ *   contracts.myContract.getValue(1, 2, 3)
+ * )
+ * ```
+ */
+export function useSingleQuery(request, options = {}) {
+    const result = useQuery({ value: request }, options);
+    return useMemo(() => {
+        return { ...result, data: result.data.value };
+    }, [result]);
+}
+/**
+ * React hook for querying iterable data structures (like arrays) from smart contracts
+ * @param total Total number of items to query
+ * @param getItem Function that generates the query for a specific index
+ * @param options Query configuration options including optional starting index
+ * @returns Object containing array of query results and status
+ * @example
+ * ```ts
+ * const { data, isLoading } = useIteratorQuery(10, (i) => contracts.myContract.getValue(i))
+ * ```
+ */
+export function useIteratorQuery(total, getItem, options = {}) {
+    const { firstIndex = 0n, ...queryParams } = options;
+    const query = useMemo(() => buildIteratorQuery(total, firstIndex, getItem), [total, firstIndex, getItem]);
+    const result = useQuery(query, queryParams);
+    return useIteratorQueryData(total, result);
+}

package/dist/react/src/blocksHandler.d.ts

@@ -0,0 +1,10 @@
+type Subscriber = (blockNumber: bigint) => void;
+export declare class BlockSubscriptionManager {
+    private subscribers;
+    private currentBlock;
+    subscribe(callback: Subscriber): () => boolean;
+    onBlockUptated(newBlock: bigint): void;
+}
+export declare function useBlockNumberSubscriber(): (callback: Subscriber) => () => boolean;
+export {};
+//# sourceMappingURL=blocksHandler.d.ts.map

package/dist/react/src/blocksHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocksHandler.d.ts","sourceRoot":"","sources":["../../../src/blocksHandler.ts"],"names":[],"mappings":"AAGA,KAAK,UAAU,GAAG,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAA;AAE/C,qBAAa,wBAAwB;IACnC,OAAO,CAAC,WAAW,CAAwB;IAC3C,OAAO,CAAC,YAAY,CAAa;IAEjC,SAAS,CAAC,QAAQ,EAAE,UAAU;IAO9B,cAAc,CAAC,QAAQ,EAAE,MAAM;CAIhC;AAED,wBAAgB,wBAAwB,eAazB,UAAU,mBAKxB"}

package/dist/react/src/blocksHandler.js

@@ -0,0 +1,32 @@
+import { useEffect, useMemo, useCallback } from 'react';
+import { usePublicClient } from 'wagmi';
+export class BlockSubscriptionManager {
+    constructor() {
+        this.subscribers = new Set();
+        this.currentBlock = 0n;
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        // Immediately call with current value
+        callback(this.currentBlock);
+        return () => this.subscribers.delete(callback);
+    }
+    onBlockUptated(newBlock) {
+        this.currentBlock = newBlock;
+        this.subscribers.forEach((sub) => sub(newBlock));
+    }
+}
+export function useBlockNumberSubscriber() {
+    const client = usePublicClient();
+    const manager = useMemo(() => new BlockSubscriptionManager(), []);
+    useEffect(() => {
+        return client?.watchBlockNumber({
+            onBlockNumber: (blockNumber) => {
+                manager.onBlockUptated(blockNumber);
+            },
+        });
+    }, [client, manager]);
+    return useCallback((callback) => {
+        return manager.subscribe(callback);
+    }, [manager]);
+}

package/dist/react/src/buildIteratorQuery.d.ts

@@ -0,0 +1,5 @@
+import { GetItemCallFunction } from '../../shared/types.js';
+export declare function buildIteratorQuery<T>(total: bigint, firstIndex: bigint, getItem: GetItemCallFunction<T>): Record<string, import("../../shared/types.js").Request & {
+    defaultValue: T;
+}>;
+//# sourceMappingURL=buildIteratorQuery.d.ts.map

package/dist/react/src/buildIteratorQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildIteratorQuery.d.ts","sourceRoot":"","sources":["../../../src/buildIteratorQuery.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAE3D,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC;;GAQvG"}

package/dist/react/src/buildIteratorQuery.js

@@ -0,0 +1,9 @@
+'use strict';
+export function buildIteratorQuery(total, firstIndex, getItem) {
+    const iterator = Array.from(new Array(Number(total)).keys());
+    return iterator.reduce((acc, index) => {
+        const realIndex = BigInt(index) + firstIndex;
+        acc[`item${realIndex}`] = getItem(realIndex);
+        return acc;
+    }, {});
+}

package/dist/react/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from './Provider.js';
+export * from './Query.js';
+export * from './Mutation.js';
+export * from './ContextQuery.js';
+export { ContextQueryProvider } from './ContextQueryManager.js';
+export { type Request, type RequestCollection, type MutationConfig, type MutationCollection, type QueryOptions, type MutationInfo, type MutationCallbacks, type AddressResolverFunction, type AddressResolverProps, type ReadContractsResult, type GetItemCallFunction, } from '../../shared/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/react/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,GACzB,MAAM,uBAAuB,CAAA"}

package/dist/react/src/index.js

@@ -0,0 +1,7 @@
+/* c8 ignore start */
+export * from './Provider.js';
+export * from './Query.js';
+export * from './Mutation.js';
+export * from './ContextQuery.js';
+export { ContextQueryProvider } from './ContextQueryManager.js';
+/* c8 ignore end */

package/dist/react/src/queryHooks.d.ts

@@ -0,0 +1,31 @@
+import { ReadContractsResult, RequestCollection } from '../../shared/types.js';
+export declare function useRequestString<T extends RequestCollection>(requests: T): string;
+export declare function useCallKeys<T extends RequestCollection>(requests: T, requestString: string): (keyof T)[];
+export declare function useDefaultData<T extends RequestCollection>(requests: T, callKeys: (keyof T)[]): { [K in keyof T]: NonNullable<T[K]["defaultValue"]>; };
+export declare function useResultData<T extends RequestCollection>(requests: T, callKeys: (keyof T)[], result: ReadContractsResult, defaultData: {
+    [K in keyof T]: NonNullable<T[K]['defaultValue']>;
+}): { [K in keyof T]: NonNullable<T[K]["defaultValue"]>; };
+export type IteratorQueryResultData<T> = {
+    value: NonNullable<T>;
+    queryIndex: bigint;
+}[];
+export type IteratorQueryResult<T> = {
+    data: IteratorQueryResultData<T>;
+    isLoading?: boolean;
+    error?: Error | null;
+};
+export declare function useIteratorQueryData<T>(total: bigint, result: {
+    isLoading?: boolean;
+    isError?: boolean;
+    error?: Error | null;
+    data: Record<string, T>;
+}): {
+    data: IteratorQueryResultData<T>;
+    isLoading: boolean;
+    error?: undefined;
+} | {
+    data: IteratorQueryResultData<T>;
+    isLoading: boolean | undefined;
+    error: Error | null | undefined;
+};
+//# sourceMappingURL=queryHooks.d.ts.map

package/dist/react/src/queryHooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryHooks.d.ts","sourceRoot":"","sources":["../../../src/queryHooks.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAE9E,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,iBAAiB,EAAE,QAAQ,EAAE,CAAC,UAExE;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,iBAAiB,EAAE,QAAQ,EAAE,CAAC,EAAE,aAAa,EAAE,MAAM,eAE1F;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,iBAAiB,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,MACvE,CAAC,mDASvB;AAED,wBAAgB,aAAa,CAAC,CAAC,SAAS,iBAAiB,EACvD,QAAQ,EAAE,CAAC,EACX,QAAQ,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,EACrB,MAAM,EAAE,mBAAmB,EAC3B,WAAW,EAAE;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC;CAAE,MAE7C,CAAC,mDAuBvB;AAED,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAAI;IAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,EAAE,CAAA;AACxF,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI;IAAE,IAAI,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,CAAA;CAAE,CAAA;AACpH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE;IACN,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,CAAA;IACpB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;CACxB;UAGwC,uBAAuB,CAAC,CAAC,CAAC;;;;;;;EAcpE"}

package/dist/react/src/queryHooks.js

@@ -0,0 +1,49 @@
+import { useMemo, useRef } from 'react';
+import { stringify } from 'viem';
+export function useRequestString(requests) {
+    return useMemo(() => stringify(requests), [stringify(requests)]);
+}
+export function useCallKeys(requests, requestString) {
+    return useMemo(() => Object.keys(requests), [requestString]);
+}
+export function useDefaultData(requests, callKeys) {
+    return useMemo(() => callKeys.reduce((acc, k) => {
+        acc[k] = requests[k].defaultValue;
+        return acc;
+    }, {}), [callKeys]);
+}
+export function useResultData(requests, callKeys, result, defaultData) {
+    const previousData = useRef(defaultData);
+    return useMemo(() => {
+        if (!result.error) {
+            const newData = callKeys.reduce((acc, k, index) => {
+                acc[k] = result.data?.[index]?.result ?? previousData.current[k] ?? requests?.[k]?.defaultValue;
+                return acc;
+            }, {});
+            previousData.current = newData;
+            return newData;
+        }
+        // During error, merge previous data with new default values
+        return callKeys.reduce((acc, k) => {
+            acc[k] = previousData.current[k] ?? requests[k].defaultValue;
+            return acc;
+        }, {});
+    }, [stringify(result.data), result.error, defaultData]);
+}
+export function useIteratorQueryData(total, result) {
+    return useMemo(() => {
+        if (total === 0n)
+            return { data: [], isLoading: false };
+        const items = Object.keys(result.data)
+            .map((k) => ({
+            value: result.data[k],
+            queryIndex: BigInt(k.replace('item', '')),
+        }))
+            .filter((i) => !!i.value);
+        return {
+            data: items,
+            isLoading: result.isLoading,
+            error: result.error,
+        };
+    }, [result.data, result.isLoading, result.error, total]);
+}

package/dist/react/src/useTransactionUpdates.d.ts

@@ -0,0 +1,3 @@
+import { MutationInfo } from '../../shared/types.js';
+export default function useTransactionUpdates(onUpdate?: (info: MutationInfo) => any): (mutation: MutationInfo) => void;
+//# sourceMappingURL=useTransactionUpdates.d.ts.map

package/dist/react/src/useTransactionUpdates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTransactionUpdates.d.ts","sourceRoot":"","sources":["../../../src/useTransactionUpdates.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAiHpD,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,GAAG,cAcrE,YAAY,UAM1B"}