@ainias42/tanstack-ids 0.1.2 → 0.1.4

package/src/generateIdsQuery.ts

@@ -1,452 +0,0 @@
-import { ArrayHelper, JsonHelper } from '@ainias42/js-helper';
-import { NotFoundError } from './NotFoundError';
-import { create, windowScheduler } from '@yornaath/batshit';
-import { createInfiniteQuery, createQuery } from 'react-query-kit';
-import { generateQuery } from './generateQuery';
-import { hashKey, useQueries, useQueryClient } from '@tanstack/react-query';
-import { hoistReactQueryKitAttributes } from './hoistReactQueryKitAttributes';
-import { useIndexedData } from './hooks/useIndexedData';
-import { useMemo, useRef } from 'react';
-import { useQueriesSubscribeToReload } from './QueryContext/useQuerySubscribeToReload';
-import type { Awaitable, Override, URecord } from '@ainias42/js-helper';
-import type { CreateInfiniteQueryOptions, CreateQueryOptions, QueryHookOptions } from 'react-query-kit';
-import type { QueryClient, QueryFunctionContext, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
-
-export type Unpacked<T> = T extends (infer U)[] ? U : T;
-
-type DeepPartial<T> = T extends object
-    ? {
-          [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)];
-        },
-        resolver: ([items], id) => {
-            const item = items?.[id];
-            if (item === undefined) {
-                throw new NotFoundError(id);
-            }
-            return item;
-        },
-        scheduler: windowScheduler(additionalQueryOptions?.schedulerTime ?? 15),
-    });
-
-    const useQueryHook = createQuery<Type, [IdType]>({
-        queryKey: [key],
-        fetcher: (identifier) => batch.fetch(identifier[0]),
-        ...additionalQueryOptions,
-    });
-
-    function useManyHook(
-        ids: IdType[],
-        otherAdditionalQueryOptions: Omit<
-            UseQueryOptions<Type, unknown, Type, [string, [IdType]]>,
-            'context' | 'fetcher' | 'queryKey'
-        > & { reloadWithContext?: boolean } = {},
-    ) {
-        const queries = ids.map((id) => ({
-            ...useQueryHook.getOptions([id]),
-            ...otherAdditionalQueryOptions,
-        }));
-
-        const results = useQueries({
-            queries: queries as any,
-        }) as UseQueryResult<Type, Error>[];
-
-        const oldData = useRef<typeof results>([]);
-        const isSame = JsonHelper.deepEqual(oldData.current, results, 1);
-
-        const returnData = useRef({} as URecord<IdType, Unpacked<typeof results>>);
-        if (!isSame) {
-            oldData.current = results;
-            returnData.current = {} as URecord<IdType, Unpacked<typeof results>>;
-            for (const [index, val] of results.entries()) {
-                const id = ids[index] as IdType;
-                returnData.current[id] = val;
-            }
-        }
-
-        const shouldReload = otherAdditionalQueryOptions.reloadWithContext ?? true;
-        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]);
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        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] });
-
-        const shouldReload = otherAdditionalQueryOptions.reloadWithContext ?? true;
-        useQueriesSubscribeToReload(
-            shouldReload ? [hashKey(useQueryHook.getKey([identifier as DeepPartial<IdType>]))] : [],
-            result.isFetching,
-            result.error,
-        );
-        return result;
-    }
-
-    function generateFilter<
-        Func extends (...args: any[]) => Promise<Type[]> | Type[],
-        FuncArguments extends Parameters<Func>['length'] extends 0 ? void : Parameters<Func> =
-            Parameters<Func>['length'] extends 0 ? void : Parameters<Func>,
-        ResultAsArray extends boolean = false,
-    >(
-        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) => {
-                    getQueryClient().setQueryData(useQueryHook.getKey([item.id as DeepPartial<IdType>]), item);
-                    return item.id;
-                });
-            },
-            {
-                initialDataUpdatedAt: 0,
-                ...additionalOptions,
-                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];
-        type HookArgs = FuncArguments extends void ? [] : FuncArguments;
-        type FilterKeyArguments = DeepPartial<HookArgs> | DeepPartial<[FuncArguments]>;
-        type FilterGetKey = (variables?: FilterKeyArguments) => readonly unknown[];
-
-        function useFilter<Args extends HookArgs>(
-            args: Args,
-            filterQueryOptions: Omit<
-                CreateQueryOptions<Type[], [FuncArguments]>,
-                'queryKey' | 'fetcher' | 'variables'
-            > = {},
-        ): ResultAsArray extends true ? UseQueryResult<Type, Error>[] : URecord<IdType, UseQueryResult<Type, Error>> {
-            const { initialData, ...otherParams } = filterQueryOptions;
-
-            let initialDataIds: IdType[] = [];
-            if (initialData) {
-                const updatedAt =
-                    (typeof otherParams.initialDataUpdatedAt === 'function'
-                        ? otherParams.initialDataUpdatedAt()
-                        : otherParams.initialDataUpdatedAt) ?? 0;
-                const initialDataArray = Array.isArray(initialData) ? initialData : initialData();
-                initialDataIds =
-                    initialDataArray?.map((item) => {
-                        const itemKey = useOne.getKey([item.id as DeepPartial<IdType>]);
-                        const state = queryClient?.getQueryState(itemKey);
-                        if (!state || state.dataUpdatedAt < updatedAt) {
-                            queryClient?.setQueryData(itemKey, item, {
-                                updatedAt,
-                            });
-                        }
-                        return item.id;
-                    }) ?? [];
-            }
-
-            const result = queryHook({
-                variables: args,
-                ...otherParams,
-                initialData: initialDataIds,
-            } as QueryHookArgument);
-
-            useQueriesSubscribeToReload(
-                [hashKey(queryHook.getKey(args as Parameters<(typeof queryHook)['getKey']>[0]))],
-                result.isFetching,
-                result.error,
-            );
-
-            // 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 indexedResult = useManyHook(result.data, { staleTime: Infinity, reloadWithContext: false });
-            const filteredIds = result.data as IdType[];
-            const arrayResult: UseQueryResult<Type, Error>[] = useMemo(
-                () => ArrayHelper.noUndefined(filteredIds?.map((id) => indexedResult[id])),
-                [filteredIds, indexedResult],
-            );
-
-            if (additionalOptions?.resultAsArray) {
-                return arrayResult as ResultAsArray extends true
-                    ? UseQueryResult<Type, Error>[]
-                    : URecord<IdType, UseQueryResult<Type, Error>>;
-            }
-            return indexedResult as ResultAsArray extends true
-                ? UseQueryResult<Type, Error>[]
-                : URecord<IdType, UseQueryResult<Type, Error>>;
-        }
-
-        const filterHook = hoistReactQueryKitAttributes(queryHook, useFilter);
-        const getFilterKey: FilterGetKey = (variables) => {
-            return queryHook.getKey(variables as Parameters<(typeof queryHook)['getKey']>[0]);
-        };
-
-        return Object.assign(filterHook, {
-            getKey: getFilterKey,
-        }) as typeof filterHook & {
-            getKey: FilterGetKey;
-        };
-    }
-
-    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');
-            }
-            return queryClient;
-        }
-
-        function findEntity(id: IdType) {
-            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
-        >({
-            ...options,
-            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>,
-                );
-                return {
-                    meta: result.meta,
-                    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,
-            ) => {
-                return options.getNextPageParam({
-                    lastPageMeta: lastPage.meta,
-                    getLastPage: () => ArrayHelper.noUndefined(lastPage.data.map(findEntity)),
-                    getAllPages: () => allPages.map((page) => ArrayHelper.noUndefined(page.data.map(findEntity))),
-                    lastPageParam,
-                    allPageParams,
-                    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,
-                      });
-                  },
-        });
-
-        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];
-
-        function useInfiniteQuery(...args: InfiniteQueryArgs) {
-            const infiniteQueryClient = useQueryClient();
-
-            let infiniteOptions: Parameters<typeof infiniteQueryHook>[0] & {
-                select?: undefined;
-            };
-            if (args.length === 1 && 'initialData' in args[0] && args[0].initialData) {
-                const { initialData } = args[0];
-                infiniteOptions = {
-                    ...args[0],
-                    initialData: {
-                        pages: initialData.pages.map((page) => ({
-                            ...page,
-                            data: page.data.map((item) => {
-                                infiniteQueryClient.setQueryData(
-                                    useQueryHook.getKey([item.id as DeepPartial<IdType>]),
-                                    item,
-                                );
-                                return item.id;
-                            }),
-                        })),
-                        pageParams: initialData.pageParams,
-                    },
-                } as Parameters<typeof infiniteQueryHook>[0] & {
-                    select?: undefined;
-                };
-            } else {
-                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],
-                        ),
-                    ),
-                ],
-                result.isFetching,
-                result.error,
-            );
-            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 indexedData = useIndexedData(manyData);
-
-            const pages = useMemo(() => {
-                return result.data
-                    ? result.data.pages.map((page) => ArrayHelper.noUndefined(page.data.map((id) => indexedData[id])))
-                    : [];
-            }, [indexedData, result.data]);
-
-            const data = !result.data ? undefined : { ...result.data, pages };
-            type TransformedResult = Omit<typeof result, 'data'> & {
-                data: typeof data;
-            };
-
-            return new Proxy(result, {
-                get(target, property, receiver) {
-                    if (property === 'data') {
-                        return data;
-                    }
-
-                    return Reflect.get(target, property, receiver);
-                },
-            }) as TransformedResult;
-        }
-
-        return hoistReactQueryKitAttributes(infiniteQueryHook, useInfiniteQuery);
-    }
-
-    const useMany = hoistReactQueryKitAttributes(useQueryHook, useManyHook);
-    const useOne = hoistReactQueryKitAttributes(useQueryHook, useOneHook);
-    return { useMany, useOne, generateFilter, generateInfiniteQuery };
-}

package/src/generateNestedIdQuery.ts

@@ -1,38 +0,0 @@
-import { generateIdsQuery } from './generateIdsQuery';
-import { hashKey } from '@tanstack/react-query';
-import { noop } from './noop';
-import { useMemo } from 'react';
-import type { DeepPartial } from './types/DeepPartial';
-
-export function generateNestedIdQuery<
-    IdType extends number | string | symbol,
-    Type extends {
-        id: IdType;
-    },
-    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
-        return useMemo(() => {
-            const keyWithArgs = `${key}-${hashKey(args)}`;
-            return generateIdsQuery(keyWithArgs, fetcherFactory(...args));
-        }, [args]);
-    };
-
-    factory.getFilterKey = (args: Args, variables?: any[]): readonly unknown[] => {
-        const keyWithArgs = `${key}-${hashKey(args)}`;
-        return generateIdsQuery(keyWithArgs, fetcherFactory(...args))
-            .generateFilter(noop as (..._: any[]) => Type[])
-            .getKey([variables]);
-    };
-
-    factory.getKey = <Variables extends [(DeepPartial<IdType> | undefined)?] | undefined = undefined>(
-        args: Args,
-        variables?: Variables,
-    ): readonly unknown[] => {
-        const keyWithArgs = `${key}-${hashKey(args)}`;
-        return generateIdsQuery(keyWithArgs, fetcherFactory(...args)).useOne.getKey(variables);
-    };
-
-    return factory;
-}

package/src/generateQuery.ts

@@ -1,58 +0,0 @@
-import { createQuery } from 'react-query-kit';
-import { hashKey } from '@tanstack/react-query';
-import { hoistReactQueryKitAttributes } from './hoistReactQueryKitAttributes';
-import { useQueriesSubscribeToReload } from './QueryContext/useQuerySubscribeToReload';
-import type { CreateQueryOptions, QueryHookResult } from 'react-query-kit';
-
-export function generateQuery<
-    Func extends (...args: any[]) => Promise<any> | any,
-    FuncArguments extends Parameters<Func>['length'] extends 0
-        ? void
-        : Parameters<Func> = Parameters<Func>['length'] extends 0 ? void : Parameters<Func>,
-    FuncReturnType extends Awaited<ReturnType<Func>> = Awaited<ReturnType<Func>>,
-    AdditionalOptionsType extends 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) => {
-            if (Array.isArray(variables)) {
-                return queryFn(...variables);
-            }
-            return queryFn();
-        },
-        initialDataUpdatedAt: 0,
-        ...additionalOptions,
-    });
-
-    type QueryHookArgument = Parameters<typeof queryHook>[0];
-    type HookArgs = FuncArguments extends void ? [] | [QueryHookArgument] : [QueryHookArgument];
-
-    function useHook<Arg extends HookArgs>(...options: Arg) {
-        type DataReturnType = Arg extends [
-            {
-                initialData: FuncReturnType | (() => FuncReturnType);
-            },
-        ]
-            ? FuncReturnType
-            : AdditionalOptionsType extends { initialData: FuncReturnType | (() => FuncReturnType) }
-              ? 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,
-        );
-
-        type Return = Arg extends [{ select: (...arg: any[]) => any }] ? ReturnType<Arg[0]['select']> : DataReturnType;
-        return result as QueryHookResult<Return, Error> & {
-            data: Return;
-        };
-    }
-
-    return hoistReactQueryKitAttributes(queryHook, useHook);
-}

package/src/hoistReactQueryKitAttributes.ts

@@ -1,16 +0,0 @@
-import type { ExposeMethods } from 'react-query-kit';
-
-export function hoistReactQueryKitAttributes<
-    ReturnType,
-    HookArgs,
-    ToFunc extends (...args: any[]) => any,
-    Error,
-    PageParam = never,
->(from: ExposeMethods<ReturnType, HookArgs, Error, PageParam>, to: ToFunc) {
-    const partialHook: Partial<ExposeMethods<ReturnType, HookArgs, Error, PageParam>> & ToFunc = Object.assign(
-        to,
-        from,
-    );
-
-    return partialHook as ExposeMethods<ReturnType, HookArgs, Error, PageParam> & ToFunc;
-}

package/src/hooks/formatInitialPage.ts

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

package/src/hooks/useArrayData.ts

@@ -1,20 +0,0 @@
-import { ArrayHelper, ObjectHelper } from '@ainias42/js-helper';
-import { useMemo } from 'react';
-import type { URecord } from '@ainias42/js-helper';
-
-export function useArrayData<DataType>(
-    result:
-        | {
-              data: DataType;
-          }[]
-        | URecord<any, { data: DataType | undefined }>
-        | undefined,
-): Exclude<DataType, undefined>[] {
-    return useMemo(
-        () =>
-            ArrayHelper.noUndefined(
-                (Array.isArray(result) ? result : ObjectHelper.values(result ?? {}))?.map((data) => data.data),
-            ),
-        [result],
-    );
-}

package/src/hooks/useIndexedData.ts

@@ -1,24 +0,0 @@
-import { ObjectHelper } from '@ainias42/js-helper';
-import { useMemo } from 'react';
-import type { URecord } from '@ainias42/js-helper';
-
-export function useIndexedData<DataType, IndexType extends number | string | symbol>(
-    result: URecord<
-        IndexType,
-        {
-            data: DataType | undefined;
-        }
-    >,
-) {
-    return useMemo(
-        () =>
-            ObjectHelper.entries(result).reduce(
-                (acc, [key, data]) => {
-                    acc[key] = data.data;
-                    return acc;
-                },
-                {} as URecord<IndexType, DataType>,
-            ),
-        [result],
-    );
-}

package/src/hooks/useInitialData.ts

@@ -1,13 +0,0 @@
-import { DateHelper } from '@ainias42/js-helper';
-import { useState } from 'react';
-
-export function useInitialData<Type>(data: Type | undefined) {
-    const [now] = useState(() => DateHelper.now());
-    if (data) {
-        return {
-            initialData: data,
-            initialDataUpdatedAt: now,
-        };
-    }
-    return {};
-}

package/src/index.ts

@@ -1,21 +0,0 @@
-export * from './generateIdsQuery';
-export * from './generateNestedIdQuery';
-export * from './generateQuery';
-export * from './hoistReactQueryKitAttributes';
-export * from './noop';
-export * from './NotFoundError';
-export * from './hooks/formatInitialPage';
-export * from './hooks/useArrayData';
-export * from './hooks/useIndexedData';
-export * from './hooks/useInitialData';
-export * from './QueryContext/QueriesContext';
-export * from './QueryContext/QueriesContextProvider';
-export * from './QueryContext/SubQueriesContext';
-export * from './QueryContext/useGenerateQueriesContextId';
-export * from './QueryContext/useQueriesError';
-export * from './QueryContext/useQueriesIsFetching';
-export * from './QueryContext/useQueriesReload';
-export * from './QueryContext/useQueriesStore';
-export * from './QueryContext/useQuerySubscribeToReload';
-export * from './QueryContext/useScopedQueriesIsFetching';
-export * from './types/DeepPartial';

package/src/noop.ts

@@ -1,2 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-export function noop() {}

package/src/types/DeepPartial.ts

@@ -1,5 +0,0 @@
-export type DeepPartial<T> = T extends object
-    ? {
-          [P in keyof T]?: DeepPartial<T[P]>;
-      }
-    : T;

package/stylelint.config.mjs

@@ -1,4 +0,0 @@
-/** @type {import('stylelint').Config} */
-export default {
-    extends: ['@ainias42/config/stylelint.config.mjs'],
-};