@ainias42/tanstack-ids 0.0.2 → 0.0.3

package/src/generateIdsQuery.ts

@@ -17,25 +17,25 @@ export type Unpacked<T> = T extends (infer U)[] ? U : T;
 
 type DeepPartial<T> = T extends object
     ? {
-        [P in keyof T]?: DeepPartial<T[P]>;
-    }
+          [P in keyof T]?: DeepPartial<T[P]>;
+      }
     : T;
 
 export function generateIdsQuery<
     IdType extends number | string | symbol,
     Type extends {
         id: IdType;
-    }
+    },
 >(
     key: string,
     fetcher: (ids: IdType[]) => Promise<Type[]> | Type[],
     additionalQueryOptions?: Omit<CreateQueryOptions<Type, [IdType]>, 'queryKey' | 'fetcher'> & {
         schedulerTime?: number;
-    }
+    },
 ) {
     const batch = create<URecord<IdType, Type>[], IdType, Type>({
-        fetcher: async ids => {
-            return [ArrayHelper.arrayToObject(await fetcher(ids), value => value.id)];
+        fetcher: async (ids) => {
+            return [ArrayHelper.arrayToObject(await fetcher(ids), (value) => value.id)];
         },
         resolver: ([items], id) => {
             const item = items?.[id];
@@ -44,13 +44,13 @@ export function generateIdsQuery<
             }
             return item;
         },
-        scheduler: windowScheduler(additionalQueryOptions?.schedulerTime ?? 15)
+        scheduler: windowScheduler(additionalQueryOptions?.schedulerTime ?? 15),
     });
 
     const useQueryHook = createQuery<Type, [IdType]>({
         queryKey: [key],
-        fetcher: identifier => batch.fetch(identifier[0]),
-        ...additionalQueryOptions
+        fetcher: (identifier) => batch.fetch(identifier[0]),
+        ...additionalQueryOptions,
     });
 
     function useManyHook(
@@ -58,16 +58,16 @@ export function generateIdsQuery<
         otherAdditionalQueryOptions: Omit<
             UseQueryOptions<Type, unknown, Type, [string, [IdType]]>,
             'context' | 'fetcher' | 'queryKey'
-        > & { reloadWithContext?: boolean } = {}
+        > & { reloadWithContext?: boolean } = {},
     ) {
-        const queries = ids.map(id => ({
+        const queries = ids.map((id) => ({
             ...useQueryHook.getOptions([id]),
-            ...otherAdditionalQueryOptions
+            ...otherAdditionalQueryOptions,
         }));
 
         const results = useQueries<Type[], QueriesResults<Type[]>>({
             // @ts-expect-error wrong type in tanstack-query
-            queries
+            queries,
         }) as UseQueryResult<Type, Error>[];
 
         const oldData = useRef<typeof results>([]);
@@ -84,29 +84,32 @@ export function generateIdsQuery<
         }
 
         const shouldReload = otherAdditionalQueryOptions.reloadWithContext ?? true;
-        const keys = shouldReload ? ids.map(id => hashKey(useQueryHook.getKey([id as DeepPartial<IdType>]))) : [];
+        const keys = shouldReload ? ids.map((id) => hashKey(useQueryHook.getKey([id as DeepPartial<IdType>]))) : [];
 
         // eslint-disable-next-line react-hooks/exhaustive-deps
-        const isFetching = useMemo(() => oldData.current.some(item => item.isFetching), [oldData.current]);
+        const isFetching = useMemo(() => oldData.current.some((item) => item.isFetching), [oldData.current]);
         // eslint-disable-next-line react-hooks/exhaustive-deps
-        const error = useMemo(() => oldData.current.find(item => item.error)?.error, [oldData.current]);
+        const error = useMemo(() => oldData.current.find((item) => item.error)?.error, [oldData.current]);
 
         useQueriesSubscribeToReload(keys, isFetching, error);
 
         return returnData.current;
     }
 
-    function useOneHook(identifier: IdType, otherAdditionalQueryOptions: Omit<
-        QueryHookOptions<Type, unknown, Type, [IdType]>,
-        'context' | 'fetcher' | 'queryKey' | 'variables'
-    > & { reloadWithContext?: boolean } = {}) {
-        const result = useQueryHook({...otherAdditionalQueryOptions, variables: [identifier]});
+    function useOneHook(
+        identifier: IdType,
+        otherAdditionalQueryOptions: Omit<
+            QueryHookOptions<Type, unknown, Type, [IdType]>,
+            'context' | 'fetcher' | 'queryKey' | 'variables'
+        > & { reloadWithContext?: boolean } = {},
+    ) {
+        const result = useQueryHook({ ...otherAdditionalQueryOptions, variables: [identifier] });
 
         const shouldReload = otherAdditionalQueryOptions.reloadWithContext ?? true;
         useQueriesSubscribeToReload(
             shouldReload ? [hashKey(useQueryHook.getKey([identifier as DeepPartial<IdType>]))] : [],
             result.isFetching,
-            result.error
+            result.error,
         );
         return result;
     }
@@ -116,29 +119,45 @@ export function generateIdsQuery<
         FuncArguments extends Parameters<Func>['length'] extends 0
             ? void
             : Parameters<Func> = Parameters<Func>['length'] extends 0 ? void : Parameters<Func>,
-        ResultAsArray extends boolean = false
+        ResultAsArray extends boolean = false,
     >(
-        queryClient: QueryClient,
         filterFunc: Func,
         additionalOptions?: Omit<CreateQueryOptions<IdType[], [FuncArguments]>, 'queryKey' | 'fetcher'> & {
             resultAsArray?: ResultAsArray;
             subKey?: string;
-        }
+        },
     ) {
+        let queryClient: QueryClient | undefined;
+
+        function getQueryClient() {
+            if (!queryClient) {
+                throw new Error('QueryClient not set');
+            }
+            return queryClient;
+        }
+
         const queryHook = generateQuery(
             `${key}-filter${additionalOptions?.subKey ? `-${additionalOptions.subKey}` : ''}`,
             async (filter: FuncArguments) => {
                 const result = await filterFunc(filter);
-                return result.map(item => {
-                    queryClient.setQueryData(useQueryHook.getKey([item.id as DeepPartial<IdType>]), item);
+                return result.map((item) => {
+                    getQueryClient().setQueryData(useQueryHook.getKey([item.id as DeepPartial<IdType>]), item);
                     return item.id;
                 });
             },
             {
                 initialDataUpdatedAt: 0,
                 ...additionalOptions,
-                initialData: (additionalOptions?.initialData as IdType[]) ?? []
-            }
+                initialData: (additionalOptions?.initialData as IdType[]) ?? [],
+                use: [
+                    function myTestMiddleware(useQueryNext) {
+                        return (options2, currentQueryClient) => {
+                            queryClient = useQueryClient(currentQueryClient);
+                            return useQueryNext(options2, queryClient);
+                        };
+                    },
+                ],
+            },
         );
 
         type QueryHookArgument = Parameters<typeof queryHook>[0];
@@ -147,12 +166,12 @@ export function generateIdsQuery<
         function useFilter<Args extends HookArgs>(
             ...args: Args
         ): ResultAsArray extends true ? UseQueryResult<Type, Error>[] : URecord<IdType, UseQueryResult<Type, Error>> {
-            const result = queryHook({variables: args} as QueryHookArgument);
+            const result = queryHook({ variables: args } as QueryHookArgument);
 
             useQueriesSubscribeToReload(
                 [hashKey(queryHook.getKey(args as Parameters<(typeof queryHook)['getKey']>[0]))],
                 result.isFetching,
-                result.error
+                result.error,
             );
 
             // When staleTime is same as filterStaleTime, then the queries will run at the same time as the filter
@@ -160,10 +179,10 @@ export function generateIdsQuery<
             // filter will be saved inside the queryClient, so the queries will be updated with the new data.
             // Same goes for reloading with context.
             // Other usages of useManyHook are not affected by this.
-            const indexedResult = useManyHook(result.data, {staleTime: Infinity, reloadWithContext: false});
+            const indexedResult = useManyHook(result.data, { staleTime: Infinity, reloadWithContext: false });
             const arrayResult: UseQueryResult<Type, Error>[] = useMemo(
-                () => ArrayHelper.noUndefined(result.data.map(id => indexedResult[id])),
-                [indexedResult, result.data]
+                () => ArrayHelper.noUndefined(result.data.map((id) => indexedResult[id])),
+                [indexedResult, result.data],
             );
 
             if (additionalOptions?.resultAsArray) {
@@ -174,48 +193,45 @@ export function generateIdsQuery<
             return indexedResult as ResultAsArray extends true
                 ? UseQueryResult<Type, Error>[]
                 : URecord<IdType, UseQueryResult<Type, Error>>;
-
         }
 
         return hoistReactQueryKitAttributes(queryHook, useFilter);
     }
 
-    function generateInfiniteQuery<PageParams, Meta, FuncArguments extends any[] = []>(
-        {
-            queryFn,
-            ...options
-        }: Omit<
-            CreateInfiniteQueryOptions<{ data: IdType[], meta: Meta }, FuncArguments, Error, PageParams>,
-            'getNextPageParam' | 'getPreviousPageParam' | 'queryKey' | 'fetcher'
-        > & {
-            queryFn: (
-                pageParams: PageParams,
-                args: FuncArguments,
-                context: QueryFunctionContext<[string, FuncArguments], PageParams>
-            ) => Awaitable<{ data: Type[], meta: Meta }>;
-            getNextPageParam: (options: {
-                getLastPage: () => Type[];
-                getAllPages: () => Type[][];
-                lastPageParam: PageParams;
-                allPageParams: PageParams[];
-                lastPageLength: number;
-                lastPageMeta: Meta;
-            }) => PageParams | undefined;
-            getPreviousPageParam?: (options: {
-                getFirstPage: () => Type[];
-                getAllPages: () => Type[][];
-                firstPageParam: PageParams;
-                allPageParams: PageParams[];
-                firstPageLength: number;
-                firstPageMeta: Meta;
-            }) => PageParams | undefined;
-        }
-    ) {
+    function generateInfiniteQuery<PageParams, Meta, FuncArguments extends any[] = []>({
+        queryFn,
+        ...options
+    }: Omit<
+        CreateInfiniteQueryOptions<{ data: IdType[]; meta: Meta }, FuncArguments, Error, PageParams>,
+        'getNextPageParam' | 'getPreviousPageParam' | 'queryKey' | 'fetcher'
+    > & {
+        queryFn: (
+            pageParams: PageParams,
+            args: FuncArguments,
+            context: QueryFunctionContext<[string, FuncArguments], PageParams>,
+        ) => Awaitable<{ data: Type[]; meta: Meta }>;
+        getNextPageParam: (options: {
+            getLastPage: () => Type[];
+            getAllPages: () => Type[][];
+            lastPageParam: PageParams;
+            allPageParams: PageParams[];
+            lastPageLength: number;
+            lastPageMeta: Meta;
+        }) => PageParams | undefined;
+        getPreviousPageParam?: (options: {
+            getFirstPage: () => Type[];
+            getAllPages: () => Type[][];
+            firstPageParam: PageParams;
+            allPageParams: PageParams[];
+            firstPageLength: number;
+            firstPageMeta: Meta;
+        }) => PageParams | undefined;
+    }) {
         let queryClient: QueryClient | undefined;
 
         function getQueryClient() {
             if (!queryClient) {
-                throw new Error("QueryClient not set");
+                throw new Error('QueryClient not set');
             }
             return queryClient;
         }
@@ -224,128 +240,157 @@ export function generateIdsQuery<
             return getQueryClient().getQueryData(useQueryHook.getKey([id as DeepPartial<IdType>])) as Type | undefined;
         }
 
-        const {getPreviousPageParam} = options;
-        const infiniteQueryHook = createInfiniteQuery<{
-            data: IdType[],
-            meta: Meta
-        }, FuncArguments, Error, PageParams>({
+        const { getPreviousPageParam } = options;
+        const infiniteQueryHook = createInfiniteQuery<
+            {
+                data: IdType[];
+                meta: Meta;
+            },
+            FuncArguments,
+            Error,
+            PageParams
+        >({
             ...options,
-            use: [function myTestMiddleware(useQueryNext) {
-                return (options, currentQueryClient) => {
-                    queryClient = useQueryClient(currentQueryClient);
-                    return useQueryNext(options, queryClient);
-                };
-            }],
+            use: [
+                function myTestMiddleware(useQueryNext) {
+                    return (options2, currentQueryClient) => {
+                        queryClient = useQueryClient(currentQueryClient);
+                        return useQueryNext(options2, queryClient);
+                    };
+                },
+            ],
             queryKey: [`${key}-infinite-query`],
             fetcher: async (_, ctx) => {
                 const context = ctx as typeof ctx & { pageParam: PageParams };
                 const result = await queryFn(
                     context.pageParam,
                     context.queryKey[1] as FuncArguments,
-                    context as QueryFunctionContext<[string, FuncArguments], PageParams>
+                    context as QueryFunctionContext<[string, FuncArguments], PageParams>,
                 );
                 return {
                     meta: result.meta,
-                    data: result.data.map(item => {
+                    data: result.data.map((item) => {
                         getQueryClient().setQueryData(useQueryHook.getKey([item.id as DeepPartial<IdType>]), item);
                         return item.id;
-                    })
+                    }),
                 };
             },
-            getNextPageParam: (lastPage: { meta: Meta, data: IdType[] }, allPages: {
-                meta: Meta,
-                data: IdType[]
-            }[], lastPageParam, allPageParams) => {
+            getNextPageParam: (
+                lastPage: { meta: Meta; data: IdType[] },
+                allPages: {
+                    meta: Meta;
+                    data: IdType[];
+                }[],
+                lastPageParam,
+                allPageParams,
+            ) => {
                 return options.getNextPageParam({
                     lastPageMeta: lastPage.meta,
                     getLastPage: () => ArrayHelper.noUndefined(lastPage.data.map(findEntity)),
-                    getAllPages: () => allPages.map(page => ArrayHelper.noUndefined(page.data.map(findEntity))),
+                    getAllPages: () => allPages.map((page) => ArrayHelper.noUndefined(page.data.map(findEntity))),
                     lastPageParam,
                     allPageParams,
-                    lastPageLength: lastPage.data.length
+                    lastPageLength: lastPage.data.length,
                 });
             },
             getPreviousPageParam: !getPreviousPageParam
                 ? undefined
                 : (firstPage, allPages, firstPageParam, allPageParams) => {
-                    return getPreviousPageParam({
-                        firstPageMeta: firstPage.meta,
-                        getFirstPage: () => ArrayHelper.noUndefined(firstPage.data.map(findEntity)),
-                        getAllPages: () => allPages.map(page => ArrayHelper.noUndefined(page.data.map(findEntity))),
-                        firstPageParam,
-                        allPageParams,
-                        firstPageLength: firstPage.data.length
-                    });
-                }
+                      return getPreviousPageParam({
+                          firstPageMeta: firstPage.meta,
+                          getFirstPage: () => ArrayHelper.noUndefined(firstPage.data.map(findEntity)),
+                          getAllPages: () => allPages.map((page) => ArrayHelper.noUndefined(page.data.map(findEntity))),
+                          firstPageParam,
+                          allPageParams,
+                          firstPageLength: firstPage.data.length,
+                      });
+                  },
         });
 
-
-        type HookOptions = Override<Parameters<typeof infiniteQueryHook>[0] & {
-            select?: undefined,
-        }, {
-            initialData?: {
-                pages: { data: Type[], meta: Meta }[],
-                pageParams: PageParams[]
+        type HookOptions = Override<
+            Parameters<typeof infiniteQueryHook>[0] & {
+                select?: undefined;
+            },
+            {
+                initialData?: {
+                    pages: { data: Type[]; meta: Meta }[];
+                    pageParams: PageParams[];
+                };
             }
-        }>;
+        >;
 
-        type InfiniteQueryArgs = FuncArguments extends ({
-            length: 0
-        } | symbol | undefined) ? ([HookOptions] | []) : ([HookOptions]);
+        type InfiniteQueryArgs = FuncArguments extends
+            | {
+                  length: 0;
+              }
+            | symbol
+            | undefined
+            ? [HookOptions] | []
+            : [HookOptions];
 
         function useInfiniteQuery(...args: InfiniteQueryArgs) {
             const infiniteQueryClient = useQueryClient();
 
             let infiniteOptions: Parameters<typeof infiniteQueryHook>[0] & {
-                select?: undefined,
+                select?: undefined;
             };
-            if (args.length === 1 && "initialData" in args[0] && args[0].initialData) {
-                const {initialData} = args[0];
+            if (args.length === 1 && 'initialData' in args[0] && args[0].initialData) {
+                const { initialData } = args[0];
                 infiniteOptions = {
                     ...args[0],
                     initialData: {
-                        pages: initialData.pages.map(page => ({
+                        pages: initialData.pages.map((page) => ({
                             ...page,
-                            data: page.data.map(item => {
-                                infiniteQueryClient.setQueryData(useQueryHook.getKey([item.id as DeepPartial<IdType>]), item);
+                            data: page.data.map((item) => {
+                                infiniteQueryClient.setQueryData(
+                                    useQueryHook.getKey([item.id as DeepPartial<IdType>]),
+                                    item,
+                                );
                                 return item.id;
-                            })
+                            }),
                         })),
-                        pageParams: initialData.pageParams
-                    }
+                        pageParams: initialData.pageParams,
+                    },
                 } as Parameters<typeof infiniteQueryHook>[0] & {
-                    select?: undefined,
+                    select?: undefined;
                 };
             } else {
-                infiniteOptions = args[0] as Parameters<typeof infiniteQueryHook>[0] & {
-                    select?: undefined,
-                };
+                infiniteOptions =
+                    (args[0] as Parameters<typeof infiniteQueryHook>[0] & {
+                        select?: undefined;
+                    }) ?? {};
             }
             const result = infiniteQueryHook(infiniteOptions);
             useQueriesSubscribeToReload(
-                [hashKey(infiniteQueryHook.getKey(infiniteOptions.variables as Parameters<(typeof infiniteQueryHook)['getKey']>[0]))],
+                [
+                    hashKey(
+                        infiniteQueryHook.getKey(
+                            infiniteOptions.variables as Parameters<(typeof infiniteQueryHook)['getKey']>[0],
+                        ),
+                    ),
+                ],
                 result.isFetching,
-                result.error
+                result.error,
             );
-            const ids = useMemo(() => result.data?.pages.flatMap(page => page.data) ?? [], [result.data?.pages]);
+            const ids = useMemo(() => result.data?.pages.flatMap((page) => page.data) ?? [], [result.data?.pages]);
 
             // When staleTime is same as filterStaleTime, then the queries will run at the same time as the filter
             // Because of this, use staleTime: Inifinity to prevent the queries from running again. The result of the
             // filter will be saved inside the queryClient, so the queries will be updated with the new data.
             // Same goes for reloading with context.
             // Other usages of useManyHook are not affected by this.
-            const manyData = useManyHook(ids, {staleTime: Infinity, reloadWithContext: false});
+            const manyData = useManyHook(ids, { staleTime: Infinity, reloadWithContext: false });
             const indexedData = useIndexedData(manyData);
 
             const pages = useMemo(() => {
                 return result.data
-                    ? result.data.pages.map(page => ArrayHelper.noUndefined(page.data.map(id => indexedData[id])))
+                    ? result.data.pages.map((page) => ArrayHelper.noUndefined(page.data.map((id) => indexedData[id])))
                     : [];
             }, [indexedData, result.data]);
 
             return {
                 ...result,
-                data: !result.data ? undefined : {...result.data, pages}
+                data: !result.data ? undefined : { ...result.data, pages },
             };
         }
 
@@ -355,5 +400,5 @@ export function generateIdsQuery<
 
     const useMany = hoistReactQueryKitAttributes(useQueryHook, useManyHook);
     const useOne = hoistReactQueryKitAttributes(useQueryHook, useOneHook);
-    return {useMany, useOne, generateFilter, generateInfiniteQuery};
+    return { useMany, useOne, generateFilter, generateInfiniteQuery };
 }

package/src/generateNestedIdQuery.ts

@@ -1,5 +1,5 @@
-import { type QueryClient, hashKey } from '@tanstack/react-query';
 import { generateIdsQuery } from '@/generateIdsQuery';
+import { hashKey } from '@tanstack/react-query';
 import { noop } from '@/noop';
 import { useMemo } from 'react';
 import type { DeepPartial } from '@/types/DeepPartial';
@@ -9,7 +9,7 @@ export function generateNestedIdQuery<
     Type extends {
         id: IdType;
     },
-    Args extends any[]
+    Args extends any[],
 >(key: string, fetcherFactory: (...args: Args) => (ids: IdType[]) => Promise<Type[]> | Type[]) {
     const factory = (...args: Args) => {
         // eslint-disable-next-line react-hooks/rules-of-hooks
@@ -22,13 +22,13 @@ export function generateNestedIdQuery<
     factory.getFilterKey = (args: Args, variables?: any[]) => {
         const keyWithArgs = `${key}-${hashKey(args)}`;
         return generateIdsQuery(keyWithArgs, fetcherFactory(...args))
-            .generateFilter(undefined as unknown as QueryClient, noop as (..._: any[]) => Type[])
+            .generateFilter(noop as (..._: any[]) => Type[])
             .getKey([variables]);
     };
 
     factory.getKey = <Variables extends [(DeepPartial<IdType> | undefined)?] | undefined = undefined>(
         args: Args,
-        variables?: Variables
+        variables?: Variables,
     ) => {
         const keyWithArgs = `${key}-${hashKey(args)}`;
         return generateIdsQuery(keyWithArgs, fetcherFactory(...args)).useOne.getKey(variables);

package/src/generateQuery.ts

@@ -13,19 +13,18 @@ export function generateQuery<
     AdditionalOptionsType extends Omit<
         CreateQueryOptions<FuncReturnType, FuncArguments>,
         'queryKey' | 'fetcher'
-    > = Omit<CreateQueryOptions<FuncReturnType, FuncArguments>, 'queryKey' | 'fetcher'>
+    > = Omit<CreateQueryOptions<FuncReturnType, FuncArguments>, 'queryKey' | 'fetcher'>,
 >(primaryKey: string, queryFn: Func, additionalOptions?: AdditionalOptionsType) {
     const queryHook = createQuery<FuncReturnType, FuncArguments>({
         queryKey: [primaryKey],
-        fetcher: variables => {
+        fetcher: (variables) => {
             if (Array.isArray(variables)) {
                 return queryFn(...variables);
-            } 
-                return queryFn();
-            
+            }
+            return queryFn();
         },
         initialDataUpdatedAt: 0,
-        ...additionalOptions
+        ...additionalOptions,
     });
 
     type QueryHookArgument = Parameters<typeof queryHook>[0];
@@ -33,20 +32,20 @@ export function generateQuery<
 
     function useHook<Arg extends HookArgs>(...options: Arg) {
         type DataReturnType = Arg extends [
-                {
-                    initialData: FuncReturnType | (() => FuncReturnType);
-                }
-            ]
+            {
+                initialData: FuncReturnType | (() => FuncReturnType);
+            },
+        ]
             ? FuncReturnType
             : AdditionalOptionsType extends { initialData: FuncReturnType | (() => FuncReturnType) }
-                ? FuncReturnType
-                : FuncReturnType | undefined;
+              ? FuncReturnType
+              : FuncReturnType | undefined;
 
         const result = queryHook(options[0] as QueryHookArgument);
         useQueriesSubscribeToReload(
             [hashKey(queryHook.getKey(options[0]?.variables as Parameters<(typeof queryHook)['getKey']>[0]))],
             result.isFetching,
-            result.error
+            result.error,
         );
 
         type Return = Arg extends [{ select: (...arg: any[]) => any }] ? ReturnType<Arg[0]['select']> : DataReturnType;

package/src/hoistReactQueryKitAttributes.ts

@@ -2,7 +2,7 @@ import type { ExposeMethods } from 'react-query-kit/build/lib/types';
 
 export function hoistReactQueryKitAttributes<ReturnType, HookArgs, ToFunc extends (...args: any) => any, Error>(
     from: ExposeMethods<ReturnType, HookArgs, Error>,
-    to: ToFunc
+    to: ToFunc,
 ) {
     const partialHook: Partial<ExposeMethods<ReturnType, HookArgs, Error>> & ToFunc = to;
     const hoistedOptions = ['fetcher', 'getKey', 'queryKeyHashFn', 'getOptions'] as const;

package/src/hooks/formatInitialPage.ts

@@ -3,7 +3,7 @@ export function formatInitialPage<Type>(data?: Type, pageParam: any = 1) {
         return {
             initialData: {
                 pages: [data],
-                pageParams: [pageParam]
+                pageParams: [pageParam],
             },
             initialDataUpdatedAt: Date.now(),
         };

package/src/hooks/useArrayData.ts

@@ -7,13 +7,13 @@ export function useArrayData<DataType>(
         | {
               data: DataType;
           }[]
-        | URecord<any, { data: DataType | undefined }>
+        | URecord<any, { data: DataType | undefined }>,
 ): Exclude<DataType, undefined>[] {
     return useMemo(
         () =>
             ArrayHelper.noUndefined(
-                (Array.isArray(result) ? result : ObjectHelper.values(result)).map(data => data.data)
+                (Array.isArray(result) ? result : ObjectHelper.values(result)).map((data) => data.data),
             ),
-        [result]
+        [result],
     );
 }

package/src/hooks/useIndexedData.ts

@@ -8,7 +8,7 @@ export function useIndexedData<DataType, IndexType extends number | string | sym
         {
             data: DataType | undefined;
         }
-    >
+    >,
 ) {
     return useMemo(
         () =>
@@ -17,8 +17,8 @@ export function useIndexedData<DataType, IndexType extends number | string | sym
                     acc[key] = data.data;
                     return acc;
                 },
-                {} as URecord<IndexType, DataType>
+                {} as URecord<IndexType, DataType>,
             ),
-        [result]
+        [result],
     );
 }