@ainias42/tanstack-ids 0.1.2 → 0.1.3

package/agents/queries.md

@@ -0,0 +1,12 @@
+# TanStack IDs Query Instructions
+
+## Query Helpers
+- For entities with an `id`, use `generateIdsQuery` from `@ainias42/tanstack-ids`.
+- For filtered entity lists, use `generateIdsQuery` with `generateFilter`.
+- Use `generateQuery` only for non-entity data or data without entity ids.
+- For entity loading hooks, expose only the hooks that are actually needed.
+- When creating a query, export the query directly instead of hiding it behind a helper hook or function, so callers can pass filter/options and avoid duplicate loads.
+
+## Query Context
+- Use the package query context helpers for shared reload, loading, and error state instead of duplicating that state locally.
+- Keep query context ids generated through the package helpers so nested or scoped queries remain isolated.

package/package.json

@@ -1,10 +1,16 @@
 {
     "name": "@ainias42/tanstack-ids",
-    "version": "0.1.2",
+    "version": "0.1.3",
     "description": "",
     "publishConfig": {
         "access": "public"
     },
+    "files": [
+        "agents",
+        "dist/**/*.d.ts",
+        "dist/**/*.js",
+        "dist/**/*.map"
+    ],
     "main": "dist/index.js",
     "exports": {
         ".": "./dist/index.js"
@@ -27,8 +33,8 @@
         "url": "gitea@git.silas.link:Ainias/libraries.git"
     },
     "dependencies": {
-        "@ainias42/react-bootstrap-mobile": "1.2.0",
-        "@ainias42/config": "1.2.0",
+        "@ainias42/react-bootstrap-mobile": "1.2.4",
+        "@ainias42/config": "1.2.1",
         "@ainias42/js-helper": ">=0.9.0",
         "@tanstack/react-query": "^5.101.0",
         "@yornaath/batshit": "^0.14.0",

package/.ctirc

@@ -1,112 +0,0 @@
-{
-  // Stream of cli spinner, you can pass stdout or stderr
-  //
-  // @mode all
-  // @default stdout
-  "spinnerStream": "stdout",
-  // Stream of cli progress, you can pass stdout or stderr
-  //
-  // @mode all
-  // @default stdout
-  "progressStream": "stdout",
-  // Stream of cli reasoner. Reasoner show name conflict error and already exist index.ts file error.
-  // You can pass stdout or stderr
-  //
-  // @mode all
-  // @default stderr
-  "reasonerStream": "stderr",
-  "options": [
-    {
-      // build mode
-      // - create: create an `index.ts` file in each directory
-      // - bundle: bundle all export information in one `index.ts` file
-      "mode": "bundle",
-      // tsconfig.json path: you must pass path with filename, like this "./tsconfig.json"
-      // only work root directory or cli parameter
-      //
-      // @mode all
-      "project": "tsconfig.json",
-      // Export filename, if you not pass this field that use "index.ts" or "index.d.ts"
-      //
-      // @mode create, bundle, remove
-      // @default index.ts
-      "exportFilename": "index.ts",
-      // add ctix comment at first line of creted index.ts file, that remark created from ctix
-      //
-      // @mode create, bundle
-      // @default false
-      "useSemicolon": true,
-      // add ctix comment at first line of creted index.ts file, that remark created from ctix
-      //
-      // @mode create, bundle
-      // @default false
-      "useBanner": false,
-      // If specified as true, adds the created date to the top of the `index.ts` file,
-      // this option only works if the `useBanner` option is enabled
-      //
-      // @mode create, bundle
-      // @default false
-      "useTimestamp": false,
-      // quote mark " or '
-      // @mode create, bundle
-      //
-      // @default '
-      "quote": "'",
-      // Use to add a literal like `"use strict"` to the top. It will be added before the banner.
-      //
-      // @mode create, bundle
-      "directive": "",
-      // keep file extension in export statement path
-      //
-      // if this option set true that see below
-      // export * from './test.ts'
-      //
-      // @mode create, bundle
-      // @default none
-      "fileExt": "none",
-      // overwrite each index.ts file
-      // @mode create, bundle
-      // @default false
-      "overwrite": true,
-      // Create a backup file if the `index.ts` file already exists.
-      // This option only works if the `overwrite` option is enabled.
-      //
-      // @mode create, bundle
-      // @default true
-      "backup": false,
-      // When generating the `index.ts` file, decide how you want to generate it
-      //
-      // @mode create, bundle
-      // @default auto
-      "generationStyle": "auto",
-      // A list of files to use when generating the index.ts file. If no value is set,
-      // the value of the include setting set in the tsconfig.json file will be used
-      //
-      // @mode create, bundle
-      "include": [
-        "src/**/*.tsx",
-        "src/**/*.ts"
-      ],
-      // A list of files to exclude when generating the index.ts file. If no value is set,
-      // the value of the exclude setting set in the tsconfig.json file is used
-      //
-      // @mode create, bundle
-      "exclude": [
-        "../../node_modules",
-        "dist/**/*",
-        "dist/src/**/*"
-      ],
-      // Output directory. Default value is same project directory
-      // @mode bundle
-      "output": "./src",
-      // remove with backup file
-      // @mode remove
-      // @default false
-      "removeBackup": false,
-      // answer `yes` to all questions
-      // @mode remove
-      // @default false
-      "forceYes": false
-    }
-  ]
-}

package/.prettierrc

@@ -1 +0,0 @@
-"@ainias42/config/prettierrc.js"

package/bin/release.sh

@@ -1,3 +0,0 @@
-#! /bin/bash
-
-../../bin/release.sh $1 tanstack-ids

package/bin/updatePackages.sh

@@ -1,3 +0,0 @@
-#! /bin/bash
-
-../../bin/updatePackages.sh tanstack-ids

package/eslint.config.js

@@ -1,3 +0,0 @@
-import defaultConfig from '@ainias42/config/eslint.config.js';
-
-export default defaultConfig;

package/src/NotFoundError.ts

@@ -1,6 +0,0 @@
-export class NotFoundError extends Error {
-    constructor(id: number | string | symbol) {
-        super(`Item with id ${String(id)} not found`);
-        this.name = 'NotFoundError';
-    }
-}

package/src/QueryContext/QueriesContext.ts

@@ -1,3 +0,0 @@
-import { createContext } from 'react';
-
-export const QueriesContext = createContext<number>(0);

package/src/QueryContext/QueriesContextProvider.tsx

@@ -1,28 +0,0 @@
-import { QueriesContext } from './QueriesContext';
-import { useGenerateQueriesContextId } from './useGenerateQueriesContextId';
-import { withMemo } from '@ainias42/react-bootstrap-mobile';
-import React from 'react';
-import type { ReactNode } from 'react';
-
-export type QueriesContextProviderProps = { children: ReactNode };
-
-export const QueriesContextProvider = withMemo(function QueriesContextProviderComponent({
-    children,
-}: QueriesContextProviderProps) {
-    // Refs
-
-    // States/Variables/Selectors
-    const id = useGenerateQueriesContextId();
-
-    // Dispatch
-
-    // Callbacks
-
-    // Effects
-
-    // Other
-
-    // RenderFunctions
-
-    return <QueriesContext.Provider value={id}>{children}</QueriesContext.Provider>;
-});

package/src/QueryContext/SubQueriesContext.tsx

@@ -1,38 +0,0 @@
-import { QueriesContext } from './QueriesContext';
-import { useClientLayoutEffect, withMemo } from '@ainias42/react-bootstrap-mobile';
-import { useGenerateQueriesContextId } from './useGenerateQueriesContextId';
-import { useQueriesStore } from './useQueriesStore';
-import React, { type ReactNode, useContext } from 'react';
-
-export type SubQueriesContextProps = { children: ReactNode; subContextId?: number };
-
-export const SubQueriesContext = withMemo(function SubQueriesContextComponent({
-    children,
-    subContextId,
-}: SubQueriesContextProps) {
-    // Refs
-
-    // States/Variables/Selectors
-    const parentId = useContext(QueriesContext);
-
-    const [addSubContext, removeSubContext] = useQueriesStore((s) => [s.addSubContext, s.removeSubContext]);
-
-    const id = useGenerateQueriesContextId();
-    const usedId = subContextId ?? id;
-
-    // Dispatch
-
-    // Callbacks
-
-    // Effects
-    useClientLayoutEffect(() => {
-        addSubContext(parentId, usedId);
-        return () => removeSubContext(parentId, usedId);
-    }, [addSubContext, usedId, parentId, removeSubContext]);
-
-    // Other
-
-    // RenderFunctions
-
-    return <QueriesContext.Provider value={usedId}>{children}</QueriesContext.Provider>;
-});

package/src/QueryContext/useGenerateQueriesContextId.ts

@@ -1,7 +0,0 @@
-import { useMemo } from 'react';
-import { useQueriesStore } from './useQueriesStore';
-
-export function useGenerateQueriesContextId() {
-    const generateId = useQueriesStore((s) => s.generateContextId);
-    return useMemo(() => generateId(), [generateId]);
-}

package/src/QueryContext/useQueriesError.ts

@@ -1,8 +0,0 @@
-import { QueriesContext } from './QueriesContext';
-import { useContext } from 'react';
-import { useQueriesStore } from './useQueriesStore';
-
-export function useQueriesError(contextId?: number) {
-    const context = useContext(QueriesContext);
-    return useQueriesStore((s) => s.getError(contextId ?? context));
-}

package/src/QueryContext/useQueriesIsFetching.ts

@@ -1,8 +0,0 @@
-import { QueriesContext } from './QueriesContext';
-import { useContext } from 'react';
-import { useQueriesStore } from './useQueriesStore';
-
-export function useQueriesIsFetching(contextId?: number) {
-    const context = useContext(QueriesContext);
-    return useQueriesStore((s) => s.isFetching(contextId ?? context));
-}

package/src/QueryContext/useQueriesReload.ts

@@ -1,14 +0,0 @@
-import { QueriesContext } from './QueriesContext';
-import { useCallback, useContext } from 'react';
-import { useQueriesStore } from './useQueriesStore';
-import { useQueryClient } from '@tanstack/react-query';
-
-export function useQueriesReload(contextId?: number) {
-    const context = useContext(QueriesContext);
-    const reloadContext = useQueriesStore((s) => s.reload);
-    const queryClient = useQueryClient();
-
-    return useCallback(async () => {
-        return reloadContext(queryClient, contextId ?? context);
-    }, [context, contextId, queryClient, reloadContext]);
-}

package/src/QueryContext/useQueriesStore.ts

@@ -1,150 +0,0 @@
-import { ObjectHelper } from '@ainias42/js-helper';
-import { create } from 'zustand';
-import { immer } from 'zustand/middleware/immer';
-import { subscribeWithSelector } from 'zustand/middleware';
-import type { QueryClient } from '@tanstack/react-query';
-import type { URecord } from '@ainias42/js-helper';
-
-type QueryItem = {
-    keys: string[];
-    isFetching: boolean;
-    error: any;
-};
-
-function initialState() {
-    return {
-        lastContextId: 0,
-        contexts: {} as URecord<
-            number,
-            {
-                lastId: number;
-                items: URecord<number, QueryItem>;
-            }
-        >,
-        subContexts: {} as URecord<number, number[]>,
-    };
-}
-
-export type QueriesStoreState = ReturnType<typeof actionsGenerator> & ReturnType<typeof initialState>;
-type SetState = (
-    newState: Partial<QueriesStoreState> | QueriesStoreState | ((state: QueriesStoreState) => QueriesStoreState | void),
-    replace?: boolean,
-) => void;
-type GetState = () => Readonly<QueriesStoreState>;
-const actionsGenerator = (set: SetState, get: GetState) => ({
-    get,
-    clear() {
-        set({ ...initialState(), ...actionsGenerator(set, get) }, true);
-    },
-    generateContextId() {
-        let id = 0;
-        set((state) => {
-            state.lastContextId++;
-            state.contexts[state.lastContextId] = {
-                lastId: 0,
-                items: {},
-            };
-            id = state.lastContextId;
-        });
-        return id;
-    },
-    setItem(contextId: number, itemId: number | undefined, item: QueryItem) {
-        let id = itemId;
-        set((state) => {
-            const contextData = state.contexts[contextId];
-            if (!contextData) {
-                return;
-            }
-
-            if (!id) {
-                contextData.lastId++;
-                id = contextData.lastId;
-            }
-            contextData.items[id] = item;
-        });
-        return id;
-    },
-    removeItem(contextId: number, itemId: number | undefined) {
-        if (!itemId) {
-            return;
-        }
-        set((state) => {
-            delete state.contexts[contextId]?.items[itemId];
-        });
-    },
-    isFetching(contextId: number): boolean {
-        const state = get();
-        return (
-            ObjectHelper.values(state.contexts[contextId]?.items ?? {}).some((item) => item.isFetching) ||
-            (state.subContexts[contextId]?.some((id) => state.isFetching(id)) ?? false)
-        );
-    },
-    isFetchingByScope(contextId: number, scope: { global: boolean; subContexts: boolean }): boolean {
-        const state = get();
-        return (
-            ((scope.global &&
-                ObjectHelper.values(state.contexts[contextId]?.items ?? {}).some((item) => item.isFetching)) ||
-                (scope.subContexts && state.subContexts[contextId]?.some((id) => state.isFetching(id)))) ??
-            false
-        );
-    },
-    getError(contextId: number): any {
-        const state = get();
-
-        const error = ObjectHelper.values(state.contexts[contextId]?.items ?? {}).find((item) => item.error)?.error;
-        if (error) {
-            return error;
-        }
-        const subContextWithError = state.subContexts[contextId]?.find((childId) => state.getError(childId));
-        if (subContextWithError) {
-            return state.getError(subContextWithError);
-        }
-        return undefined;
-    },
-    getAllKeys(contextId: number): Set<string> {
-        const state = get();
-
-        const keys = new Set(ObjectHelper.values(state.contexts[contextId]?.items ?? {}).flatMap((item) => item.keys));
-
-        const subContext = state.subContexts[contextId];
-        if (subContext) {
-            for (const childId of subContext) {
-                const subKeys = state.getAllKeys(childId);
-                for (const key of subKeys) {
-                    keys.add(key);
-                }
-            }
-        }
-
-        return keys;
-    },
-    reload(queryClient: QueryClient, contextId: number) {
-        const state = get();
-
-        const keys = state.getAllKeys(contextId);
-        return queryClient.refetchQueries({
-            predicate: (query) => keys.has(query.queryHash),
-        });
-    },
-    addSubContext(parent: number, child: number) {
-        set((state) => {
-            const newChildren = state.subContexts[parent] ?? [];
-            newChildren.push(child);
-            state.subContexts[parent] = newChildren;
-        });
-    },
-    removeSubContext(parent: number, child: number) {
-        set((state) => {
-            state.subContexts[parent] = state.subContexts[parent]?.filter((id) => id !== child);
-        });
-    },
-});
-
-export const useQueriesStore = create<QueriesStoreState>()(
-    subscribeWithSelector(
-        immer((set, get) => ({
-            ...initialState(),
-            ...actionsGenerator(set, get),
-        })),
-    ),
-);

package/src/QueryContext/useQuerySubscribeToReload.ts

@@ -1,24 +0,0 @@
-import { QueriesContext } from './QueriesContext';
-import { useClientLayoutEffect } from '@ainias42/react-bootstrap-mobile';
-import { useContext, useRef } from 'react';
-import { useQueriesStore } from './useQueriesStore';
-
-export function useQueriesSubscribeToReload(keys: string[], isFetching: boolean, error: any) {
-    const contextId = useContext(QueriesContext);
-    const setItem = useQueriesStore((s) => s.setItem);
-    const removeItem = useQueriesStore((s) => s.removeItem);
-    const id = useRef<number | undefined>(undefined);
-
-    useClientLayoutEffect(() => {
-        id.current = setItem(contextId, id.current, {
-            keys,
-            error,
-            isFetching,
-        });
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [contextId, error, isFetching, setItem, ...keys]);
-
-    useClientLayoutEffect(() => {
-        return () => removeItem(contextId, id.current);
-    }, [contextId, removeItem]);
-}

package/src/QueryContext/useScopedQueriesIsFetching.ts

@@ -1,9 +0,0 @@
-import { QueriesContext } from './QueriesContext';
-import { useContext } from 'react';
-import { useQueriesStore } from './useQueriesStore';
-
-export function useScopedQueriesIsFetching(scope: { global: boolean; subContexts: boolean }, contextId?: number) {
-    const context = useContext(QueriesContext);
-
-    return useQueriesStore((s) => s.isFetchingByScope(contextId ?? context, scope));
-}

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'],
-};

package/tsconfig.json

@@ -1,11 +0,0 @@
-{
-    "extends": "@ainias42/config/tsconfig.json",
-    "compilerOptions": {
-        "jsx": "react",
-        "rootDir": "./src",
-        "outDir": "./dist",
-        "declaration": true
-    },
-    "exclude": ["../../node_modules", "dist/**/*", "dist/src/**/*"],
-    "include": ["src/**/*.tsx", "src/**/*.ts"]
-}