@gravity-ui/data-source 0.2.1 → 0.3.0-alpha.0

package/build/esm/core/types/DataSource.d.ts

@@ -1,16 +1,16 @@
 import type { idle } from '../constants';
-export type DataSourceKey = readonly unknown[];
+export type DataSourceKey = ReadonlyArray<unknown>;
 export type DataSourceTag = string;
 declare const errorHintSymbol: unique symbol;
 declare const stateHintSymbol: unique symbol;
-export interface DataSource<TContext, TParams, TRequest, TResponse, TData, TError, TOptions, TState, TFetchContext> {
+export interface DataSource<TContext, TParams, TRequest extends object, TResponse, TData, TError, TOptions extends object, TState, TFetchContext> {
     readonly name: string;
     fetch: (context: TContext, fetchContext: TFetchContext, request: TRequest) => Promise<TResponse> | TResponse;
     tags?: (params: ActualParams<TParams, TRequest>) => DataSourceTag[];
     transformParams?: (params: TParams) => TRequest;
     transformResponse?: (response: TResponse) => TData;
     [errorHintSymbol]?: TError;
-    options?: TOptions;
+    options?: Partial<TOptions>;
     [stateHintSymbol]?: TState;
 }
 export type AnyDataSource = DataSource<any, any, any, any, any, any, any, any, any>;

package/build/esm/core/types/DataSource.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["DataSource.ts"],"sourcesContent":["import type {idle} from '../constants';\n\nexport type DataSourceKey = readonly unknown[];\nexport type DataSourceTag = string;\n\ndeclare const errorHintSymbol: unique symbol;\ndeclare const stateHintSymbol: unique symbol;\n\nexport interface DataSource<\n    TContext,\n    TParams,\n    TRequest,\n    TResponse,\n    TData,\n    TError,\n    TOptions,\n    TState,\n    TFetchContext,\n> {\n    readonly name: string;\n\n    fetch: (\n        context: TContext,\n        fetchContext: TFetchContext,\n        request: TRequest,\n    ) => Promise<TResponse> | TResponse;\n    tags?: (params: ActualParams<TParams, TRequest>) => DataSourceTag[];\n\n    transformParams?: (params: TParams) => TRequest;\n    transformResponse?: (response: TResponse) => TData;\n\n    [errorHintSymbol]?: TError;\n\n    options?: TOptions;\n    [stateHintSymbol]?: TState;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyDataSource = DataSource<any, any, any, any, any, any, any, any, any>;\n\nexport type DataSourceContext<TDataSource> =\n    TDataSource extends DataSource<\n        infer TContext,\n        infer _TParams,\n        infer _TRequest,\n        infer _TResponse,\n        infer _TData,\n        infer _TError,\n        infer _TOptions,\n        infer _TState,\n        infer _TFetchContext\n    >\n        ? TContext\n        : never;\n\nexport type DataSourceParams<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer TParams,\n        infer TRequest,\n        infer _TResponse,\n        infer _TData,\n        infer _TError,\n        infer _TOptions,\n        infer _TState,\n        infer _TFetchContext\n    >\n        ? ActualParams<TParams, TRequest>\n        : never;\n\nexport type DataSourceRequest<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer _TParams,\n        infer TRequest,\n        infer _TResponse,\n        infer _TData,\n        infer _TError,\n        infer _TOptions,\n        infer _TState,\n        infer _TFetchContext\n    >\n        ? TRequest\n        : never;\n\nexport type DataSourceResponse<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer _TParams,\n        infer _TRequest,\n        infer TResponse,\n        infer _TData,\n        infer _TError,\n        infer _TOptions,\n        infer _TState,\n        infer _TFetchContext\n    >\n        ? TResponse\n        : never;\n\nexport type DataSourceData<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer _TParams,\n        infer _TRequest,\n        infer TResponse,\n        infer TData,\n        infer _TError,\n        infer _TOptions,\n        infer _TState,\n        infer _TFetchContext\n    >\n        ? ActualData<TData, TResponse>\n        : never;\n\nexport type DataSourceError<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer _TParams,\n        infer _TRequest,\n        infer _TResponse,\n        infer _TData,\n        infer TError,\n        infer _TOptions,\n        infer _TState,\n        infer _TFetchContext\n    >\n        ? TError\n        : never;\n\nexport type DataSourceOptions<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer _TParams,\n        infer _TRequest,\n        infer _TResponse,\n        infer _TData,\n        infer _TError,\n        infer TOptions,\n        infer _TState,\n        infer _TFetchContext\n    >\n        ? TOptions\n        : never;\n\nexport type DataSourceState<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer _TParams,\n        infer _TRequest,\n        infer _TResponse,\n        infer _TData,\n        infer _TError,\n        infer _TOptions,\n        infer TState,\n        infer _TFetchContext\n    >\n        ? TState\n        : never;\n\nexport type DataSourceFetchContext<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer _TParams,\n        infer _TRequest,\n        infer _TResponse,\n        infer _TData,\n        infer _TError,\n        infer _TOptions,\n        infer _TState,\n        infer TFetchContext\n    >\n        ? TFetchContext\n        : never;\n\nexport type ActualParams<TParams, TRequest> =\n    | (unknown extends TParams ? TRequest : TParams)\n    | typeof idle;\n\nexport type ActualData<TData, TResponse> = unknown extends TData ? TResponse : TData;\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["DataSource.ts"],"sourcesContent":["import type {idle} from '../constants';\n\nexport type DataSourceKey = ReadonlyArray<unknown>;\nexport type DataSourceTag = string;\n\ndeclare const errorHintSymbol: unique symbol;\ndeclare const stateHintSymbol: unique symbol;\n\nexport interface DataSource<\n    TContext,\n    TParams,\n    TRequest extends object,\n    TResponse,\n    TData,\n    TError,\n    TOptions extends object,\n    TState,\n    TFetchContext,\n> {\n    readonly name: string;\n\n    fetch: (\n        context: TContext,\n        fetchContext: TFetchContext,\n        request: TRequest,\n    ) => Promise<TResponse> | TResponse;\n    tags?: (params: ActualParams<TParams, TRequest>) => DataSourceTag[];\n\n    transformParams?: (params: TParams) => TRequest;\n    transformResponse?: (response: TResponse) => TData;\n\n    [errorHintSymbol]?: TError;\n\n    options?: Partial<TOptions>;\n    [stateHintSymbol]?: TState;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyDataSource = DataSource<any, any, any, any, any, any, any, any, any>;\n\nexport type DataSourceContext<TDataSource> =\n    TDataSource extends DataSource<\n        infer TContext,\n        infer _TParams,\n        infer _TRequest,\n        infer _TResponse,\n        infer _TData,\n        infer _TError,\n        infer _TOptions,\n        infer _TState,\n        infer _TFetchContext\n    >\n        ? TContext\n        : never;\n\nexport type DataSourceParams<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer TParams,\n        infer TRequest,\n        infer _TResponse,\n        infer _TData,\n        infer _TError,\n        infer _TOptions,\n        infer _TState,\n        infer _TFetchContext\n    >\n        ? ActualParams<TParams, TRequest>\n        : never;\n\nexport type DataSourceRequest<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer _TParams,\n        infer TRequest,\n        infer _TResponse,\n        infer _TData,\n        infer _TError,\n        infer _TOptions,\n        infer _TState,\n        infer _TFetchContext\n    >\n        ? TRequest\n        : never;\n\nexport type DataSourceResponse<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer _TParams,\n        infer _TRequest,\n        infer TResponse,\n        infer _TData,\n        infer _TError,\n        infer _TOptions,\n        infer _TState,\n        infer _TFetchContext\n    >\n        ? TResponse\n        : never;\n\nexport type DataSourceData<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer _TParams,\n        infer _TRequest,\n        infer TResponse,\n        infer TData,\n        infer _TError,\n        infer _TOptions,\n        infer _TState,\n        infer _TFetchContext\n    >\n        ? ActualData<TData, TResponse>\n        : never;\n\nexport type DataSourceError<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer _TParams,\n        infer _TRequest,\n        infer _TResponse,\n        infer _TData,\n        infer TError,\n        infer _TOptions,\n        infer _TState,\n        infer _TFetchContext\n    >\n        ? TError\n        : never;\n\nexport type DataSourceOptions<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer _TParams,\n        infer _TRequest,\n        infer _TResponse,\n        infer _TData,\n        infer _TError,\n        infer TOptions,\n        infer _TState,\n        infer _TFetchContext\n    >\n        ? TOptions\n        : never;\n\nexport type DataSourceState<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer _TParams,\n        infer _TRequest,\n        infer _TResponse,\n        infer _TData,\n        infer _TError,\n        infer _TOptions,\n        infer TState,\n        infer _TFetchContext\n    >\n        ? TState\n        : never;\n\nexport type DataSourceFetchContext<TDataSource> =\n    TDataSource extends DataSource<\n        infer _TContenxt,\n        infer _TParams,\n        infer _TRequest,\n        infer _TResponse,\n        infer _TData,\n        infer _TError,\n        infer _TOptions,\n        infer _TState,\n        infer TFetchContext\n    >\n        ? TFetchContext\n        : never;\n\nexport type ActualParams<TParams, TRequest> =\n    | (unknown extends TParams ? TRequest : TParams)\n    | typeof idle;\n\nexport type ActualData<TData, TResponse> = unknown extends TData ? TResponse : TData;\n"],"mappings":"","ignoreList":[]}

package/build/esm/core/utils/composeFullKey.d.ts

@@ -1,2 +1,2 @@
 import type { AnyDataSource, DataSourceParams } from '../types/DataSource';
-export declare const composeFullKey: <TDataSource extends AnyDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>) => readonly string[];
+export declare const composeFullKey: <TDataSource extends AnyDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>) => ReadonlyArray<string>;

package/build/esm/core/utils/composeFullKey.js.map

@@ -1 +1 @@
-{"version":3,"names":["composeKey","composeFullKey","dataSource","params","_dataSource$tags","_dataSource$tags2","tags","call","name","concat","_toConsumableArray"],"sources":["composeFullKey.ts"],"sourcesContent":["import type {AnyDataSource, DataSourceParams} from '../types/DataSource';\n\nimport {composeKey} from './composeKey';\n\nexport const composeFullKey = <TDataSource extends AnyDataSource>(\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n): readonly string[] => {\n    const tags = dataSource.tags?.(params) ?? [];\n\n    return [dataSource.name, ...tags, composeKey(dataSource, params)];\n};\n"],"mappings":";AAEA,SAAQA,UAAU,QAAO,cAAc;AAEvC,OAAO,IAAMC,cAAc,GAAG,SAAjBA,cAAcA,CACvBC,UAAuB,EACvBC,MAAqC,EACjB;EAAA,IAAAC,gBAAA,EAAAC,iBAAA;EACpB,IAAMC,IAAI,IAAAF,gBAAA,IAAAC,iBAAA,GAAGH,UAAU,CAACI,IAAI,cAAAD,iBAAA,uBAAfA,iBAAA,CAAAE,IAAA,CAAAL,UAAU,EAAQC,MAAM,CAAC,cAAAC,gBAAA,cAAAA,gBAAA,GAAI,EAAE;EAE5C,QAAQF,UAAU,CAACM,IAAI,EAAAC,MAAA,CAAAC,kBAAA,CAAKJ,IAAI,IAAEN,UAAU,CAACE,UAAU,EAAEC,MAAM,CAAC;AACpE,CAAC","ignoreList":[]}
+{"version":3,"names":["composeKey","composeFullKey","dataSource","params","_dataSource$tags","_dataSource$tags2","tags","call","name","concat","_toConsumableArray"],"sources":["composeFullKey.ts"],"sourcesContent":["import type {AnyDataSource, DataSourceParams} from '../types/DataSource';\n\nimport {composeKey} from './composeKey';\n\nexport const composeFullKey = <TDataSource extends AnyDataSource>(\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n): ReadonlyArray<string> => {\n    const tags = dataSource.tags?.(params) ?? [];\n\n    return [dataSource.name, ...tags, composeKey(dataSource, params)];\n};\n"],"mappings":";AAEA,SAAQA,UAAU,QAAO,cAAc;AAEvC,OAAO,IAAMC,cAAc,GAAG,SAAjBA,cAAcA,CACvBC,UAAuB,EACvBC,MAAqC,EACb;EAAA,IAAAC,gBAAA,EAAAC,iBAAA;EACxB,IAAMC,IAAI,IAAAF,gBAAA,IAAAC,iBAAA,GAAGH,UAAU,CAACI,IAAI,cAAAD,iBAAA,uBAAfA,iBAAA,CAAAE,IAAA,CAAAL,UAAU,EAAQC,MAAM,CAAC,cAAAC,gBAAA,cAAAA,gBAAA,GAAI,EAAE;EAE5C,QAAQF,UAAU,CAACM,IAAI,EAAAC,MAAA,CAAAC,kBAAA,CAAKJ,IAAI,IAAEN,UAAU,CAACE,UAAU,EAAEC,MAAM,CAAC;AACpE,CAAC","ignoreList":[]}

package/build/esm/core/utils/composeKey.js

@@ -1,7 +1,7 @@
 // TODO(DakEnviy): Do not use react-query in core
-import { hashQueryKey } from '@tanstack/react-query';
+import { hashKey } from '@tanstack/react-query';
 import { idle } from '../constants';
 export var composeKey = function composeKey(dataSource, params) {
-  return params === idle ? "".concat(dataSource.name, ":idle") : "".concat(dataSource.name, "(").concat(hashQueryKey(params), ")");
+  return params === idle ? "".concat(dataSource.name, ":idle") : "".concat(dataSource.name, "(").concat(hashKey(params), ")");
 };
 // #sourceMappingURL=composeKey.js.map

package/build/esm/core/utils/composeKey.js.map

@@ -1 +1 @@
-{"version":3,"names":["hashQueryKey","idle","composeKey","dataSource","params","concat","name"],"sources":["composeKey.ts"],"sourcesContent":["// TODO(DakEnviy): Do not use react-query in core\nimport {hashQueryKey} from '@tanstack/react-query';\n\nimport {idle} from '../constants';\nimport type {AnyDataSource, DataSourceParams} from '../types/DataSource';\n\nexport const composeKey = <TDataSource extends AnyDataSource>(\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n): string =>\n    params === idle ? `${dataSource.name}:idle` : `${dataSource.name}(${hashQueryKey(params)})`;\n"],"mappings":"AAAA;AACA,SAAQA,YAAY,QAAO,uBAAuB;AAElD,SAAQC,IAAI,QAAO,cAAc;AAGjC,OAAO,IAAMC,UAAU,GAAG,SAAbA,UAAUA,CACnBC,UAAuB,EACvBC,MAAqC;EAAA,OAErCA,MAAM,KAAKH,IAAI,MAAAI,MAAA,CAAMF,UAAU,CAACG,IAAI,gBAAAD,MAAA,CAAaF,UAAU,CAACG,IAAI,OAAAD,MAAA,CAAIL,YAAY,CAACI,MAAM,CAAC,MAAG;AAAA","ignoreList":[]}
+{"version":3,"names":["hashKey","idle","composeKey","dataSource","params","concat","name"],"sources":["composeKey.ts"],"sourcesContent":["// TODO(DakEnviy): Do not use react-query in core\nimport {hashKey} from '@tanstack/react-query';\n\nimport {idle} from '../constants';\nimport type {AnyDataSource, DataSourceParams} from '../types/DataSource';\n\nexport const composeKey = <TDataSource extends AnyDataSource>(\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n): string =>\n    params === idle ? `${dataSource.name}:idle` : `${dataSource.name}(${hashKey(params)})`;\n"],"mappings":"AAAA;AACA,SAAQA,OAAO,QAAO,uBAAuB;AAE7C,SAAQC,IAAI,QAAO,cAAc;AAGjC,OAAO,IAAMC,UAAU,GAAG,SAAbA,UAAUA,CACnBC,UAAuB,EACvBC,MAAqC;EAAA,OAErCA,MAAM,KAAKH,IAAI,MAAAI,MAAA,CAAMF,UAAU,CAACG,IAAI,gBAAAD,MAAA,CAAaF,UAAU,CAACG,IAAI,OAAAD,MAAA,CAAIL,OAAO,CAACI,MAAM,CAAC,MAAG;AAAA","ignoreList":[]}

package/build/esm/react/components/DataInfiniteLoader/types.d.ts

@@ -5,7 +5,7 @@ export interface MoreViewProps {
     isLoading: boolean;
     onClick: () => void;
 }
-export interface DataInfiniteLoaderProps<TError, TLoadingViewProps extends {} = {}, TErrorViewProps extends ErrorViewProps<TError> = ErrorViewProps<TError>, TMoreViewProps extends MoreViewProps = MoreViewProps> {
+export interface DataInfiniteLoaderProps<TError, TLoadingViewProps extends object = {}, TErrorViewProps extends ErrorViewProps<TError> = ErrorViewProps<TError>, TMoreViewProps extends MoreViewProps = MoreViewProps> {
     status: DataLoaderStatus;
     error: TError | null;
     errorAction?: ErrorAction | ErrorAction['handler'];

package/build/esm/react/components/DataInfiniteLoader/types.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type {ComponentType, ReactNode} from 'react';\n\nimport type {DataLoaderStatus} from '../../../core';\nimport type {ErrorAction, ErrorViewProps} from '../types';\n\nexport interface MoreViewProps {\n    isLoading: boolean;\n    onClick: () => void;\n}\n\nexport interface DataInfiniteLoaderProps<\n    TError,\n    TLoadingViewProps extends {} = {},\n    TErrorViewProps extends ErrorViewProps<TError> = ErrorViewProps<TError>,\n    TMoreViewProps extends MoreViewProps = MoreViewProps,\n> {\n    status: DataLoaderStatus;\n    error: TError | null;\n    errorAction?: ErrorAction | ErrorAction['handler'];\n    hasNextPage: boolean;\n    fetchNextPage: () => unknown;\n    isFetchingNextPage: boolean;\n    LoadingView: ComponentType<TLoadingViewProps>;\n    ErrorView: ComponentType<TErrorViewProps>;\n    MoreView: ComponentType<TMoreViewProps>;\n    loadingViewProps?: TLoadingViewProps;\n    errorViewProps?: Omit<TErrorViewProps, keyof ErrorViewProps<TError>>;\n    moreViewProps?: Omit<TMoreViewProps, keyof MoreViewProps>;\n    children: ReactNode;\n}\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type {ComponentType, ReactNode} from 'react';\n\nimport type {DataLoaderStatus} from '../../../core';\nimport type {ErrorAction, ErrorViewProps} from '../types';\n\nexport interface MoreViewProps {\n    isLoading: boolean;\n    onClick: () => void;\n}\n\nexport interface DataInfiniteLoaderProps<\n    TError,\n    TLoadingViewProps extends object = {},\n    TErrorViewProps extends ErrorViewProps<TError> = ErrorViewProps<TError>,\n    TMoreViewProps extends MoreViewProps = MoreViewProps,\n> {\n    status: DataLoaderStatus;\n    error: TError | null;\n    errorAction?: ErrorAction | ErrorAction['handler'];\n    hasNextPage: boolean;\n    fetchNextPage: () => unknown;\n    isFetchingNextPage: boolean;\n    LoadingView: ComponentType<TLoadingViewProps>;\n    ErrorView: ComponentType<TErrorViewProps>;\n    MoreView: ComponentType<TMoreViewProps>;\n    loadingViewProps?: TLoadingViewProps;\n    errorViewProps?: Omit<TErrorViewProps, keyof ErrorViewProps<TError>>;\n    moreViewProps?: Omit<TMoreViewProps, keyof MoreViewProps>;\n    children: ReactNode;\n}\n"],"mappings":"","ignoreList":[]}

package/build/esm/react/components/DataLoader/types.d.ts

@@ -1,7 +1,7 @@
 import type { ComponentType, ReactNode } from 'react';
 import type { DataLoaderStatus } from '../../../core';
 import type { ErrorAction, ErrorViewProps } from '../types';
-export interface DataLoaderProps<TError, TLoadingViewProps extends {} = {}, TErrorViewProps extends ErrorViewProps<TError> = ErrorViewProps<TError>> {
+export interface DataLoaderProps<TError, TLoadingViewProps extends object = {}, TErrorViewProps extends ErrorViewProps<TError> = ErrorViewProps<TError>> {
     status: DataLoaderStatus;
     error: TError | null;
     errorAction?: ErrorAction | ErrorAction['handler'];

package/build/esm/react/components/DataLoader/types.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type {ComponentType, ReactNode} from 'react';\n\nimport type {DataLoaderStatus} from '../../../core';\nimport type {ErrorAction, ErrorViewProps} from '../types';\n\nexport interface DataLoaderProps<\n    TError,\n    TLoadingViewProps extends {} = {},\n    TErrorViewProps extends ErrorViewProps<TError> = ErrorViewProps<TError>,\n> {\n    status: DataLoaderStatus;\n    error: TError | null;\n    errorAction?: ErrorAction | ErrorAction['handler'];\n    LoadingView: ComponentType<TLoadingViewProps>;\n    ErrorView: ComponentType<TErrorViewProps>;\n    loadingViewProps?: TLoadingViewProps;\n    errorViewProps?: Omit<TErrorViewProps, keyof ErrorViewProps<TError>>;\n    children: ReactNode;\n}\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type {ComponentType, ReactNode} from 'react';\n\nimport type {DataLoaderStatus} from '../../../core';\nimport type {ErrorAction, ErrorViewProps} from '../types';\n\nexport interface DataLoaderProps<\n    TError,\n    TLoadingViewProps extends object = {},\n    TErrorViewProps extends ErrorViewProps<TError> = ErrorViewProps<TError>,\n> {\n    status: DataLoaderStatus;\n    error: TError | null;\n    errorAction?: ErrorAction | ErrorAction['handler'];\n    LoadingView: ComponentType<TLoadingViewProps>;\n    ErrorView: ComponentType<TErrorViewProps>;\n    loadingViewProps?: TLoadingViewProps;\n    errorViewProps?: Omit<TErrorViewProps, keyof ErrorViewProps<TError>>;\n    children: ReactNode;\n}\n"],"mappings":"","ignoreList":[]}

package/build/esm/react-query/hooks/useQueryData.d.ts

@@ -1,3 +1,3 @@
 import type { DataSourceOptions, DataSourceParams, DataSourceState } from '../../core';
 import type { AnyQueryDataSource } from '../types';
-export declare const useQueryData: <TDataSource extends AnyQueryDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>, options?: DataSourceOptions<TDataSource>) => DataSourceState<TDataSource>;
+export declare const useQueryData: <TDataSource extends AnyQueryDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>, options?: Partial<DataSourceOptions<TDataSource>>) => DataSourceState<TDataSource>;

package/build/esm/react-query/hooks/useQueryData.js

@@ -1,19 +1,23 @@
 import { useInfiniteQueryData } from '../impl/infinite/hooks';
 import { usePlainQueryData } from '../impl/plain/hooks';
+import { notReachable } from '../utils/notReachable';
 import { useQueryContext } from './useQueryContext';
 export var useQueryData = function useQueryData(dataSource, params, options) {
   var context = useQueryContext();
+  var type = dataSource.type;
   var state;
 
   // Do not change data source type in the same hook call
-  if (dataSource.type === 'plain') {
+  if (type === 'plain') {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     state = usePlainQueryData(context, dataSource, params, options);
-  } else if (dataSource.type === 'infinite') {
+  } else if (type === 'infinite') {
     // eslint-disable-next-line react-hooks/rules-of-hooks
-    state = useInfiniteQueryData(context, dataSource, params, options);
+    state = useInfiniteQueryData(context, dataSource, params,
+    // TS can't calculate types in this place
+    options);
   } else {
-    throw new Error('Data Source type must be plain or infinite');
+    return notReachable(type, "Data Source type must be plain or infinite, got: ".concat(type));
   }
   return state;
 };

package/build/esm/react-query/hooks/useQueryData.js.map

@@ -1 +1 @@
-{"version":3,"names":["useInfiniteQueryData","usePlainQueryData","useQueryContext","useQueryData","dataSource","params","options","context","state","type","Error"],"sources":["useQueryData.ts"],"sourcesContent":["import type {DataSourceOptions, DataSourceParams, DataSourceState} from '../../core';\nimport {useInfiniteQueryData} from '../impl/infinite/hooks';\nimport {usePlainQueryData} from '../impl/plain/hooks';\nimport type {AnyQueryDataSource} from '../types';\n\nimport {useQueryContext} from './useQueryContext';\n\nexport const useQueryData = <TDataSource extends AnyQueryDataSource>(\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: DataSourceOptions<TDataSource>,\n): DataSourceState<TDataSource> => {\n    const context = useQueryContext();\n\n    let state: DataSourceState<AnyQueryDataSource> | undefined;\n\n    // Do not change data source type in the same hook call\n    if (dataSource.type === 'plain') {\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        state = usePlainQueryData(context, dataSource, params, options);\n    } else if (dataSource.type === 'infinite') {\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        state = useInfiniteQueryData(context, dataSource, params, options);\n    } else {\n        throw new Error('Data Source type must be plain or infinite');\n    }\n\n    return state as DataSourceState<TDataSource>;\n};\n"],"mappings":"AACA,SAAQA,oBAAoB,QAAO,wBAAwB;AAC3D,SAAQC,iBAAiB,QAAO,qBAAqB;AAGrD,SAAQC,eAAe,QAAO,mBAAmB;AAEjD,OAAO,IAAMC,YAAY,GAAG,SAAfA,YAAYA,CACrBC,UAAuB,EACvBC,MAAqC,EACrCC,OAAwC,EACT;EAC/B,IAAMC,OAAO,GAAGL,eAAe,CAAC,CAAC;EAEjC,IAAIM,KAAsD;;EAE1D;EACA,IAAIJ,UAAU,CAACK,IAAI,KAAK,OAAO,EAAE;IAC7B;IACAD,KAAK,GAAGP,iBAAiB,CAACM,OAAO,EAAEH,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EACnE,CAAC,MAAM,IAAIF,UAAU,CAACK,IAAI,KAAK,UAAU,EAAE;IACvC;IACAD,KAAK,GAAGR,oBAAoB,CAACO,OAAO,EAAEH,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EACtE,CAAC,MAAM;IACH,MAAM,IAAII,KAAK,CAAC,4CAA4C,CAAC;EACjE;EAEA,OAAOF,KAAK;AAChB,CAAC","ignoreList":[]}
+{"version":3,"names":["useInfiniteQueryData","usePlainQueryData","notReachable","useQueryContext","useQueryData","dataSource","params","options","context","type","state","concat"],"sources":["useQueryData.ts"],"sourcesContent":["import type {DataSourceOptions, DataSourceParams, DataSourceState} from '../../core';\nimport {useInfiniteQueryData} from '../impl/infinite/hooks';\nimport type {AnyInfiniteQueryDataSource} from '../impl/infinite/types';\nimport {usePlainQueryData} from '../impl/plain/hooks';\nimport type {AnyQueryDataSource} from '../types';\nimport {notReachable} from '../utils/notReachable';\n\nimport {useQueryContext} from './useQueryContext';\n\nexport const useQueryData = <TDataSource extends AnyQueryDataSource>(\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: Partial<DataSourceOptions<TDataSource>>,\n): DataSourceState<TDataSource> => {\n    const context = useQueryContext();\n\n    const type = dataSource.type;\n    let state: DataSourceState<AnyQueryDataSource> | undefined;\n\n    // Do not change data source type in the same hook call\n    if (type === 'plain') {\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        state = usePlainQueryData(context, dataSource, params, options);\n    } else if (type === 'infinite') {\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        state = useInfiniteQueryData(\n            context,\n            dataSource,\n            params,\n            // TS can't calculate types in this place\n            options as Partial<DataSourceOptions<AnyInfiniteQueryDataSource>> | undefined,\n        );\n    } else {\n        return notReachable(type, `Data Source type must be plain or infinite, got: ${type}`);\n    }\n\n    return state as DataSourceState<TDataSource>;\n};\n"],"mappings":"AACA,SAAQA,oBAAoB,QAAO,wBAAwB;AAE3D,SAAQC,iBAAiB,QAAO,qBAAqB;AAErD,SAAQC,YAAY,QAAO,uBAAuB;AAElD,SAAQC,eAAe,QAAO,mBAAmB;AAEjD,OAAO,IAAMC,YAAY,GAAG,SAAfA,YAAYA,CACrBC,UAAuB,EACvBC,MAAqC,EACrCC,OAAiD,EAClB;EAC/B,IAAMC,OAAO,GAAGL,eAAe,CAAC,CAAC;EAEjC,IAAMM,IAAI,GAAGJ,UAAU,CAACI,IAAI;EAC5B,IAAIC,KAAsD;;EAE1D;EACA,IAAID,IAAI,KAAK,OAAO,EAAE;IAClB;IACAC,KAAK,GAAGT,iBAAiB,CAACO,OAAO,EAAEH,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EACnE,CAAC,MAAM,IAAIE,IAAI,KAAK,UAAU,EAAE;IAC5B;IACAC,KAAK,GAAGV,oBAAoB,CACxBQ,OAAO,EACPH,UAAU,EACVC,MAAM;IACN;IACAC,OACJ,CAAC;EACL,CAAC,MAAM;IACH,OAAOL,YAAY,CAACO,IAAI,sDAAAE,MAAA,CAAsDF,IAAI,CAAE,CAAC;EACzF;EAEA,OAAOC,KAAK;AAChB,CAAC","ignoreList":[]}

package/build/esm/react-query/impl/infinite/factory.d.ts

@@ -1,2 +1,2 @@
 import type { InfiniteQueryDataSource } from './types';
-export declare const makeInfiniteQueryDataSource: <TParams, TRequest, TResponse, TData, TError>(config: Omit<InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError>, "type">) => InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError>;
+export declare const makeInfiniteQueryDataSource: <TParams, TRequest extends object, TResponse, TData, TError>(config: Omit<InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError>, "type">) => InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError>;

package/build/esm/react-query/impl/infinite/factory.js.map

@@ -1 +1 @@
-{"version":3,"names":["makeInfiniteQueryDataSource","config","_objectSpread","type"],"sources":["factory.ts"],"sourcesContent":["import type {InfiniteQueryDataSource} from './types';\n\nexport const makeInfiniteQueryDataSource = <TParams, TRequest, TResponse, TData, TError>(\n    config: Omit<InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError>, 'type'>,\n): InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError> => ({\n    ...config,\n    type: 'infinite',\n});\n"],"mappings":";AAEA,OAAO,IAAMA,2BAA2B,GAAG,SAA9BA,2BAA2BA,CACpCC,MAA0F;EAAA,OAAAC,aAAA,CAAAA,aAAA,KAEvFD,MAAM;IACTE,IAAI,EAAE;EAAU;AAAA,CAClB","ignoreList":[]}
+{"version":3,"names":["makeInfiniteQueryDataSource","config","_objectSpread","type"],"sources":["factory.ts"],"sourcesContent":["import type {InfiniteQueryDataSource} from './types';\n\nexport const makeInfiniteQueryDataSource = <\n    TParams,\n    TRequest extends object,\n    TResponse,\n    TData,\n    TError,\n>(\n    config: Omit<InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError>, 'type'>,\n): InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError> => ({\n    ...config,\n    type: 'infinite',\n});\n"],"mappings":";AAEA,OAAO,IAAMA,2BAA2B,GAAG,SAA9BA,2BAA2BA,CAOpCC,MAA0F;EAAA,OAAAC,aAAA,CAAAA,aAAA,KAEvFD,MAAM;IACTE,IAAI,EAAE;EAAU;AAAA,CAClB","ignoreList":[]}

package/build/esm/react-query/impl/infinite/hooks.d.ts

@@ -1,3 +1,3 @@
-import type { DataSourceContext, DataSourceOptions, DataSourceParams } from '../../../core';
+import type { DataSourceContext, DataSourceOptions, DataSourceParams, DataSourceState } from '../../../core';
 import type { AnyInfiniteQueryDataSource } from './types';
-export declare const useInfiniteQueryData: <TDataSource extends AnyInfiniteQueryDataSource>(context: DataSourceContext<TDataSource>, dataSource: TDataSource, params: DataSourceParams<TDataSource>, options?: DataSourceOptions<TDataSource>) => import("../../../core").DataSourceState<TDataSource>;
+export declare const useInfiniteQueryData: <TDataSource extends AnyInfiniteQueryDataSource>(context: DataSourceContext<TDataSource>, dataSource: TDataSource, params: DataSourceParams<TDataSource>, options?: Partial<DataSourceOptions<TDataSource>>) => DataSourceState<TDataSource>;

package/build/esm/react-query/impl/infinite/hooks.js

@@ -1,11 +1,8 @@
-import { useMemo } from 'react';
 import { useInfiniteQuery } from '@tanstack/react-query';
 import { composeOptions, transformResult } from './utils';
 export var useInfiniteQueryData = function useInfiniteQueryData(context, dataSource, params, options) {
   var composedOptions = composeOptions(context, dataSource, params, options);
   var result = useInfiniteQuery(composedOptions);
-  return useMemo(function () {
-    return transformResult(result);
-  }, [result]);
+  return transformResult(result);
 };
 // #sourceMappingURL=hooks.js.map

package/build/esm/react-query/impl/infinite/hooks.js.map

@@ -1 +1 @@
-{"version":3,"names":["useMemo","useInfiniteQuery","composeOptions","transformResult","useInfiniteQueryData","context","dataSource","params","options","composedOptions","result"],"sources":["hooks.ts"],"sourcesContent":["import {useMemo} from 'react';\n\nimport {useInfiniteQuery} from '@tanstack/react-query';\n\nimport type {DataSourceContext, DataSourceOptions, DataSourceParams} from '../../../core';\n\nimport type {AnyInfiniteQueryDataSource} from './types';\nimport {composeOptions, transformResult} from './utils';\n\nexport const useInfiniteQueryData = <TDataSource extends AnyInfiniteQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: DataSourceOptions<TDataSource>,\n) => {\n    const composedOptions = composeOptions(context, dataSource, params, options);\n    const result = useInfiniteQuery(composedOptions);\n\n    return useMemo(() => transformResult(result), [result]);\n};\n"],"mappings":"AAAA,SAAQA,OAAO,QAAO,OAAO;AAE7B,SAAQC,gBAAgB,QAAO,uBAAuB;AAKtD,SAAQC,cAAc,EAAEC,eAAe,QAAO,SAAS;AAEvD,OAAO,IAAMC,oBAAoB,GAAG,SAAvBA,oBAAoBA,CAC7BC,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAwC,EACvC;EACD,IAAMC,eAAe,GAAGP,cAAc,CAACG,OAAO,EAAEC,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EAC5E,IAAME,MAAM,GAAGT,gBAAgB,CAACQ,eAAe,CAAC;EAEhD,OAAOT,OAAO,CAAC;IAAA,OAAMG,eAAe,CAACO,MAAM,CAAC;EAAA,GAAE,CAACA,MAAM,CAAC,CAAC;AAC3D,CAAC","ignoreList":[]}
+{"version":3,"names":["useInfiniteQuery","composeOptions","transformResult","useInfiniteQueryData","context","dataSource","params","options","composedOptions","result"],"sources":["hooks.ts"],"sourcesContent":["import {useInfiniteQuery} from '@tanstack/react-query';\n\nimport type {\n    DataSourceContext,\n    DataSourceOptions,\n    DataSourceParams,\n    DataSourceState,\n} from '../../../core';\n\nimport type {AnyInfiniteQueryDataSource} from './types';\nimport {composeOptions, transformResult} from './utils';\n\nexport const useInfiniteQueryData = <TDataSource extends AnyInfiniteQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: Partial<DataSourceOptions<TDataSource>>,\n): DataSourceState<TDataSource> => {\n    const composedOptions = composeOptions(context, dataSource, params, options);\n    const result = useInfiniteQuery(composedOptions);\n\n    return transformResult(result);\n};\n"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,uBAAuB;AAUtD,SAAQC,cAAc,EAAEC,eAAe,QAAO,SAAS;AAEvD,OAAO,IAAMC,oBAAoB,GAAG,SAAvBA,oBAAoBA,CAC7BC,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAiD,EAClB;EAC/B,IAAMC,eAAe,GAAGP,cAAc,CAACG,OAAO,EAAEC,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EAC5E,IAAME,MAAM,GAAGT,gBAAgB,CAACQ,eAAe,CAAC;EAEhD,OAAON,eAAe,CAACO,MAAM,CAAC;AAClC,CAAC","ignoreList":[]}

package/build/esm/react-query/impl/infinite/types.d.ts

@@ -1,18 +1,20 @@
-import type { InfiniteQueryObserverOptions, InfiniteQueryObserverResult, QueryFunctionContext } from '@tanstack/react-query';
+import type { InfiniteData, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, QueryFunctionContext } from '@tanstack/react-query';
 import type { Overwrite } from 'utility-types';
 import type { ActualData, DataLoaderStatus, DataSource, DataSourceKey } from '../../../core';
 import type { QueryDataSourceContext } from '../../types';
-export type InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError> = DataSource<QueryDataSourceContext, TParams, TRequest, TResponse, TData, TError, InfiniteQueryObserverOptions<TResponse, TError, ActualData<TData, TResponse>, TResponse>, ResultWrapper<InfiniteQueryObserverResult<ActualData<TData, TResponse>, TError>>, QueryFunctionContext<DataSourceKey, Partial<TRequest> | undefined>> & {
+export type InfiniteQueryDataSource<TParams, TRequest extends object, TResponse, TData, TError> = DataSource<QueryDataSourceContext, TParams, TRequest, TResponse, TData, TError, InfiniteQueryObserverOptions<TResponse, TError, InfiniteData<ActualData<TData, TResponse>, Partial<TRequest>>, TResponse, DataSourceKey, Partial<TRequest>>, ResultWrapper<InfiniteQueryObserverResult<InfiniteData<ActualData<TData, TResponse>, Partial<TRequest>>, TError>, TRequest, TResponse, TData, TError>, QueryFunctionContext<DataSourceKey, Partial<TRequest>>> & {
     type: 'infinite';
-    next: (lastPage: TResponse, allPages: TResponse[]) => Partial<TRequest> | undefined;
-    prev?: (firstPage: TResponse, allPages: TResponse[]) => Partial<TRequest> | undefined;
+    next: (lastPage: TResponse, allPages: TResponse[]) => Partial<TRequest> | null | undefined;
+    prev?: (firstPage: TResponse, allPages: TResponse[]) => Partial<TRequest> | null | undefined;
 };
 export type AnyInfiniteQueryDataSource = InfiniteQueryDataSource<any, any, any, any, any>;
-type ResultWrapper<T> = T extends InfiniteQueryObserverResult<infer TData> ? Overwrite<T, {
+export type AnyPageParam = Partial<any>;
+type ResultWrapper<TResult, TRequest, TResponse, TData, TError> = TResult extends InfiniteQueryObserverResult<InfiniteData<ActualData<TData, TResponse>, Partial<TRequest>>, TError> ? Overwrite<TResult, {
     status: DataLoaderStatus;
-    data: TData;
+    data: DataWrapper<ActualData<TData, TResponse>>;
 }> & {
-    originalStatus: T['status'];
-    originalData: T['data'];
+    originalStatus: TResult['status'];
+    originalData: TResult['data'];
 } : never;
+type DataWrapper<TActualData> = TActualData extends any[] ? TActualData : TActualData[];
 export {};

package/build/esm/react-query/impl/infinite/types.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type {\n    InfiniteQueryObserverOptions,\n    InfiniteQueryObserverResult,\n    QueryFunctionContext,\n} from '@tanstack/react-query';\nimport type {Overwrite} from 'utility-types';\n\nimport type {ActualData, DataLoaderStatus, DataSource, DataSourceKey} from '../../../core';\nimport type {QueryDataSourceContext} from '../../types';\n\nexport type InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError> = DataSource<\n    QueryDataSourceContext,\n    TParams,\n    TRequest,\n    TResponse,\n    TData,\n    TError,\n    InfiniteQueryObserverOptions<TResponse, TError, ActualData<TData, TResponse>, TResponse>,\n    ResultWrapper<InfiniteQueryObserverResult<ActualData<TData, TResponse>, TError>>,\n    QueryFunctionContext<DataSourceKey, Partial<TRequest> | undefined>\n> & {\n    type: 'infinite';\n    next: (lastPage: TResponse, allPages: TResponse[]) => Partial<TRequest> | undefined;\n    prev?: (firstPage: TResponse, allPages: TResponse[]) => Partial<TRequest> | undefined;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyInfiniteQueryDataSource = InfiniteQueryDataSource<any, any, any, any, any>;\n\ntype ResultWrapper<T> =\n    T extends InfiniteQueryObserverResult<infer TData>\n        ? Overwrite<T, {status: DataLoaderStatus; data: TData}> & {\n              originalStatus: T['status'];\n              originalData: T['data'];\n          }\n        : never;\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type {\n    InfiniteData,\n    InfiniteQueryObserverOptions,\n    InfiniteQueryObserverResult,\n    QueryFunctionContext,\n} from '@tanstack/react-query';\nimport type {Overwrite} from 'utility-types';\n\nimport type {ActualData, DataLoaderStatus, DataSource, DataSourceKey} from '../../../core';\nimport type {QueryDataSourceContext} from '../../types';\n\nexport type InfiniteQueryDataSource<\n    TParams,\n    TRequest extends object,\n    TResponse,\n    TData,\n    TError,\n> = DataSource<\n    QueryDataSourceContext,\n    TParams,\n    TRequest,\n    TResponse,\n    TData,\n    TError,\n    InfiniteQueryObserverOptions<\n        TResponse,\n        TError,\n        InfiniteData<ActualData<TData, TResponse>, Partial<TRequest>>,\n        TResponse,\n        DataSourceKey,\n        Partial<TRequest>\n    >,\n    ResultWrapper<\n        InfiniteQueryObserverResult<\n            InfiniteData<ActualData<TData, TResponse>, Partial<TRequest>>,\n            TError\n        >,\n        TRequest,\n        TResponse,\n        TData,\n        TError\n    >,\n    QueryFunctionContext<DataSourceKey, Partial<TRequest>>\n> & {\n    type: 'infinite';\n    next: (lastPage: TResponse, allPages: TResponse[]) => Partial<TRequest> | null | undefined;\n    prev?: (firstPage: TResponse, allPages: TResponse[]) => Partial<TRequest> | null | undefined;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyInfiniteQueryDataSource = InfiniteQueryDataSource<any, any, any, any, any>;\n\n// It is used instead of `Partial<DataSourceRequest<TDataSource>>` because TS can't calculate type\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyPageParam = Partial<any>;\n\ntype ResultWrapper<TResult, TRequest, TResponse, TData, TError> =\n    TResult extends InfiniteQueryObserverResult<\n        InfiniteData<ActualData<TData, TResponse>, Partial<TRequest>>,\n        TError\n    >\n        ? Overwrite<\n              TResult,\n              {status: DataLoaderStatus; data: DataWrapper<ActualData<TData, TResponse>>}\n          > & {\n              originalStatus: TResult['status'];\n              originalData: TResult['data'];\n          }\n        : never;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype DataWrapper<TActualData> = TActualData extends any[] ? TActualData : TActualData[];\n"],"mappings":"","ignoreList":[]}

package/build/esm/react-query/impl/infinite/utils.d.ts

@@ -1,5 +1,5 @@
-import type { InfiniteQueryObserverOptions, InfiniteQueryObserverResult } from '@tanstack/react-query';
-import type { DataSourceContext, DataSourceData, DataSourceError, DataSourceOptions, DataSourceParams, DataSourceResponse, DataSourceState } from '../../../core';
-import type { AnyInfiniteQueryDataSource } from './types';
-export declare const composeOptions: <TDataSource extends AnyInfiniteQueryDataSource>(context: DataSourceContext<TDataSource>, dataSource: TDataSource, params: DataSourceParams<TDataSource>, options?: DataSourceOptions<TDataSource>) => InfiniteQueryObserverOptions<DataSourceResponse<TDataSource>, DataSourceError<TDataSource>, DataSourceData<TDataSource>, DataSourceResponse<TDataSource>>;
-export declare const transformResult: <TDataSource extends AnyInfiniteQueryDataSource>(result: InfiniteQueryObserverResult<DataSourceData<TDataSource>, DataSourceError<TDataSource>>) => DataSourceState<TDataSource>;
+import type { InfiniteData, InfiniteQueryObserverOptions, InfiniteQueryObserverResult } from '@tanstack/react-query';
+import type { DataSourceContext, DataSourceData, DataSourceError, DataSourceKey, DataSourceOptions, DataSourceParams, DataSourceResponse, DataSourceState } from '../../../core';
+import type { AnyInfiniteQueryDataSource, AnyPageParam } from './types';
+export declare const composeOptions: <TDataSource extends AnyInfiniteQueryDataSource>(context: DataSourceContext<TDataSource>, dataSource: TDataSource, params: DataSourceParams<TDataSource>, options?: Partial<DataSourceOptions<TDataSource>>) => InfiniteQueryObserverOptions<DataSourceResponse<TDataSource>, DataSourceError<TDataSource>, InfiniteData<DataSourceData<TDataSource>, AnyPageParam>, DataSourceResponse<TDataSource>, DataSourceKey, AnyPageParam>;
+export declare const transformResult: <TDataSource extends AnyInfiniteQueryDataSource>(result: InfiniteQueryObserverResult<InfiniteData<DataSourceData<TDataSource>, AnyPageParam>, DataSourceError<TDataSource>>) => DataSourceState<TDataSource>;

package/build/esm/react-query/impl/infinite/utils.js

@@ -1,35 +1,37 @@
-import _typeof from "@babel/runtime/helpers/typeof";
 import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import { skipToken } from '@tanstack/react-query';
 import { composeFullKey, idle } from '../../../core';
 import { normalizeStatus } from '../../utils/normalizeStatus';
 var EMPTY_ARRAY = [];
+var EMPTY_OBJECT = {};
 export var composeOptions = function composeOptions(context, dataSource, params, options) {
   var transformParams = dataSource.transformParams,
     transformResponse = dataSource.transformResponse,
     next = dataSource.next,
     prev = dataSource.prev;
-  return _objectSpread(_objectSpread({}, dataSource.options), {}, {
-    enabled: params !== idle,
+  var queryFn = function queryFn(fetchContext) {
+    var request = transformParams ? transformParams(params) : params;
+    var paginatedRequest = _objectSpread(_objectSpread({}, request), fetchContext.pageParam);
+    return dataSource.fetch(context, fetchContext, paginatedRequest);
+  };
+  return _objectSpread(_objectSpread({
     queryKey: composeFullKey(dataSource, params),
-    queryFn: function queryFn(fetchContext) {
-      var actualParams = transformParams ? transformParams(params) : params;
-      var request = _typeof(actualParams) === 'object' ? _objectSpread(_objectSpread({}, actualParams), fetchContext.pageParam) : actualParams;
-      return dataSource.fetch(context, fetchContext, request);
-    },
+    queryFn: params === idle ? skipToken : queryFn,
     select: transformResponse ? function (data) {
       return _objectSpread(_objectSpread({}, data), {}, {
         pages: data.pages.map(transformResponse)
       });
     } : undefined,
+    initialPageParam: EMPTY_OBJECT,
     getNextPageParam: next,
     getPreviousPageParam: prev
-  }, options);
+  }, dataSource.options), options);
 };
 export var transformResult = function transformResult(result) {
   var _result$data$pages$fl, _result$data;
   return _objectSpread(_objectSpread({}, result), {}, {
     status: normalizeStatus(result.status, result.fetchStatus),
-    data: (_result$data$pages$fl = (_result$data = result.data) === null || _result$data === void 0 ? void 0 : _result$data.pages.flat()) !== null && _result$data$pages$fl !== void 0 ? _result$data$pages$fl : EMPTY_ARRAY,
+    data: (_result$data$pages$fl = (_result$data = result.data) === null || _result$data === void 0 ? void 0 : _result$data.pages.flat(1)) !== null && _result$data$pages$fl !== void 0 ? _result$data$pages$fl : EMPTY_ARRAY,
     originalStatus: result.status,
     originalData: result.data
   });

package/build/esm/react-query/impl/infinite/utils.js.map

@@ -1 +1 @@
-{"version":3,"names":["composeFullKey","idle","normalizeStatus","EMPTY_ARRAY","composeOptions","context","dataSource","params","options","transformParams","transformResponse","next","prev","_objectSpread","enabled","queryKey","queryFn","fetchContext","actualParams","request","_typeof","pageParam","fetch","select","data","pages","map","undefined","getNextPageParam","getPreviousPageParam","transformResult","result","_result$data$pages$fl","_result$data","status","fetchStatus","flat","originalStatus","originalData"],"sources":["utils.ts"],"sourcesContent":["import type {\n    InfiniteQueryObserverOptions,\n    InfiniteQueryObserverResult,\n    QueryFunctionContext,\n} from '@tanstack/react-query';\n\nimport {composeFullKey, idle} from '../../../core';\nimport type {\n    DataSourceContext,\n    DataSourceData,\n    DataSourceError,\n    DataSourceKey,\n    DataSourceOptions,\n    DataSourceParams,\n    DataSourceRequest,\n    DataSourceResponse,\n    DataSourceState,\n} from '../../../core';\nimport {normalizeStatus} from '../../utils/normalizeStatus';\n\nimport type {AnyInfiniteQueryDataSource} from './types';\n\nconst EMPTY_ARRAY: unknown[] = [];\n\nexport const composeOptions = <TDataSource extends AnyInfiniteQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: DataSourceOptions<TDataSource>,\n): InfiniteQueryObserverOptions<\n    DataSourceResponse<TDataSource>,\n    DataSourceError<TDataSource>,\n    DataSourceData<TDataSource>,\n    DataSourceResponse<TDataSource>\n> => {\n    const {transformParams, transformResponse, next, prev} = dataSource;\n\n    return {\n        ...dataSource.options,\n        enabled: params !== idle,\n        queryKey: composeFullKey(dataSource, params),\n        queryFn: (\n            fetchContext: QueryFunctionContext<\n                DataSourceKey,\n                Partial<DataSourceRequest<TDataSource>> | undefined\n            >,\n        ) => {\n            const actualParams = transformParams ? transformParams(params) : params;\n            const request =\n                typeof actualParams === 'object'\n                    ? {...actualParams, ...fetchContext.pageParam}\n                    : actualParams;\n\n            return dataSource.fetch(context, fetchContext, request);\n        },\n        select: transformResponse\n            ? (data) => ({...data, pages: data.pages.map(transformResponse)})\n            : undefined,\n        getNextPageParam: next,\n        getPreviousPageParam: prev,\n        ...options,\n    };\n};\n\nexport const transformResult = <TDataSource extends AnyInfiniteQueryDataSource>(\n    result: InfiniteQueryObserverResult<DataSourceData<TDataSource>, DataSourceError<TDataSource>>,\n) => {\n    return {\n        ...result,\n        status: normalizeStatus(result.status, result.fetchStatus),\n        data: result.data?.pages.flat() ?? EMPTY_ARRAY,\n        originalStatus: result.status,\n        originalData: result.data,\n    } as DataSourceState<TDataSource>;\n};\n"],"mappings":";;AAMA,SAAQA,cAAc,EAAEC,IAAI,QAAO,eAAe;AAYlD,SAAQC,eAAe,QAAO,6BAA6B;AAI3D,IAAMC,WAAsB,GAAG,EAAE;AAEjC,OAAO,IAAMC,cAAc,GAAG,SAAjBA,cAAcA,CACvBC,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAwC,EAMvC;EACD,IAAOC,eAAe,GAAmCH,UAAU,CAA5DG,eAAe;IAAEC,iBAAiB,GAAgBJ,UAAU,CAA3CI,iBAAiB;IAAEC,IAAI,GAAUL,UAAU,CAAxBK,IAAI;IAAEC,IAAI,GAAIN,UAAU,CAAlBM,IAAI;EAErD,OAAAC,aAAA,CAAAA,aAAA,KACOP,UAAU,CAACE,OAAO;IACrBM,OAAO,EAAEP,MAAM,KAAKN,IAAI;IACxBc,QAAQ,EAAEf,cAAc,CAACM,UAAU,EAAEC,MAAM,CAAC;IAC5CS,OAAO,EAAE,SAATA,OAAOA,CACHC,YAGC,EACA;MACD,IAAMC,YAAY,GAAGT,eAAe,GAAGA,eAAe,CAACF,MAAM,CAAC,GAAGA,MAAM;MACvE,IAAMY,OAAO,GACTC,OAAA,CAAOF,YAAY,MAAK,QAAQ,GAAAL,aAAA,CAAAA,aAAA,KACtBK,YAAY,GAAKD,YAAY,CAACI,SAAS,IAC3CH,YAAY;MAEtB,OAAOZ,UAAU,CAACgB,KAAK,CAACjB,OAAO,EAAEY,YAAY,EAAEE,OAAO,CAAC;IAC3D,CAAC;IACDI,MAAM,EAAEb,iBAAiB,GACnB,UAACc,IAAI;MAAA,OAAAX,aAAA,CAAAA,aAAA,KAAUW,IAAI;QAAEC,KAAK,EAAED,IAAI,CAACC,KAAK,CAACC,GAAG,CAAChB,iBAAiB;MAAC;IAAA,CAAE,GAC/DiB,SAAS;IACfC,gBAAgB,EAAEjB,IAAI;IACtBkB,oBAAoB,EAAEjB;EAAI,GACvBJ,OAAO;AAElB,CAAC;AAED,OAAO,IAAMsB,eAAe,GAAG,SAAlBA,eAAeA,CACxBC,MAA8F,EAC7F;EAAA,IAAAC,qBAAA,EAAAC,YAAA;EACD,OAAApB,aAAA,CAAAA,aAAA,KACOkB,MAAM;IACTG,MAAM,EAAEhC,eAAe,CAAC6B,MAAM,CAACG,MAAM,EAAEH,MAAM,CAACI,WAAW,CAAC;IAC1DX,IAAI,GAAAQ,qBAAA,IAAAC,YAAA,GAAEF,MAAM,CAACP,IAAI,cAAAS,YAAA,uBAAXA,YAAA,CAAaR,KAAK,CAACW,IAAI,CAAC,CAAC,cAAAJ,qBAAA,cAAAA,qBAAA,GAAI7B,WAAW;IAC9CkC,cAAc,EAAEN,MAAM,CAACG,MAAM;IAC7BI,YAAY,EAAEP,MAAM,CAACP;EAAI;AAEjC,CAAC","ignoreList":[]}
+{"version":3,"names":["skipToken","composeFullKey","idle","normalizeStatus","EMPTY_ARRAY","EMPTY_OBJECT","composeOptions","context","dataSource","params","options","transformParams","transformResponse","next","prev","queryFn","fetchContext","request","paginatedRequest","_objectSpread","pageParam","fetch","queryKey","select","data","pages","map","undefined","initialPageParam","getNextPageParam","getPreviousPageParam","transformResult","result","_result$data$pages$fl","_result$data","status","fetchStatus","flat","originalStatus","originalData"],"sources":["utils.ts"],"sourcesContent":["import {skipToken} from '@tanstack/react-query';\nimport type {\n    InfiniteData,\n    InfiniteQueryObserverOptions,\n    InfiniteQueryObserverResult,\n    QueryFunctionContext,\n} from '@tanstack/react-query';\n\nimport {composeFullKey, idle} from '../../../core';\nimport type {\n    DataSourceContext,\n    DataSourceData,\n    DataSourceError,\n    DataSourceKey,\n    DataSourceOptions,\n    DataSourceParams,\n    DataSourceResponse,\n    DataSourceState,\n} from '../../../core';\nimport {normalizeStatus} from '../../utils/normalizeStatus';\n\nimport type {AnyInfiniteQueryDataSource, AnyPageParam} from './types';\n\nconst EMPTY_ARRAY: unknown[] = [];\nconst EMPTY_OBJECT = {};\n\nexport const composeOptions = <TDataSource extends AnyInfiniteQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: Partial<DataSourceOptions<TDataSource>>,\n): InfiniteQueryObserverOptions<\n    DataSourceResponse<TDataSource>,\n    DataSourceError<TDataSource>,\n    InfiniteData<DataSourceData<TDataSource>, AnyPageParam>,\n    DataSourceResponse<TDataSource>,\n    DataSourceKey,\n    AnyPageParam\n> => {\n    const {transformParams, transformResponse, next, prev} = dataSource;\n\n    const queryFn = (\n        fetchContext: QueryFunctionContext<DataSourceKey, AnyPageParam>,\n    ): DataSourceResponse<TDataSource> | Promise<DataSourceResponse<TDataSource>> => {\n        const request = transformParams ? transformParams(params) : params;\n        const paginatedRequest = {...request, ...fetchContext.pageParam};\n\n        return dataSource.fetch(context, fetchContext, paginatedRequest);\n    };\n\n    return {\n        queryKey: composeFullKey(dataSource, params),\n        queryFn: params === idle ? skipToken : queryFn,\n        select: transformResponse\n            ? (data) => ({...data, pages: data.pages.map(transformResponse)})\n            : undefined,\n        initialPageParam: EMPTY_OBJECT,\n        getNextPageParam: next,\n        getPreviousPageParam: prev,\n        ...dataSource.options,\n        ...options,\n    };\n};\n\nexport const transformResult = <TDataSource extends AnyInfiniteQueryDataSource>(\n    result: InfiniteQueryObserverResult<\n        InfiniteData<DataSourceData<TDataSource>, AnyPageParam>,\n        DataSourceError<TDataSource>\n    >,\n): DataSourceState<TDataSource> => {\n    return {\n        ...result,\n        status: normalizeStatus(result.status, result.fetchStatus),\n        data: result.data?.pages.flat(1) ?? EMPTY_ARRAY,\n        originalStatus: result.status,\n        originalData: result.data,\n    } as DataSourceState<TDataSource>;\n};\n"],"mappings":";AAAA,SAAQA,SAAS,QAAO,uBAAuB;AAQ/C,SAAQC,cAAc,EAAEC,IAAI,QAAO,eAAe;AAWlD,SAAQC,eAAe,QAAO,6BAA6B;AAI3D,IAAMC,WAAsB,GAAG,EAAE;AACjC,IAAMC,YAAY,GAAG,CAAC,CAAC;AAEvB,OAAO,IAAMC,cAAc,GAAG,SAAjBA,cAAcA,CACvBC,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAiD,EAQhD;EACD,IAAOC,eAAe,GAAmCH,UAAU,CAA5DG,eAAe;IAAEC,iBAAiB,GAAgBJ,UAAU,CAA3CI,iBAAiB;IAAEC,IAAI,GAAUL,UAAU,CAAxBK,IAAI;IAAEC,IAAI,GAAIN,UAAU,CAAlBM,IAAI;EAErD,IAAMC,OAAO,GAAG,SAAVA,OAAOA,CACTC,YAA+D,EACc;IAC7E,IAAMC,OAAO,GAAGN,eAAe,GAAGA,eAAe,CAACF,MAAM,CAAC,GAAGA,MAAM;IAClE,IAAMS,gBAAgB,GAAAC,aAAA,CAAAA,aAAA,KAAOF,OAAO,GAAKD,YAAY,CAACI,SAAS,CAAC;IAEhE,OAAOZ,UAAU,CAACa,KAAK,CAACd,OAAO,EAAES,YAAY,EAAEE,gBAAgB,CAAC;EACpE,CAAC;EAED,OAAAC,aAAA,CAAAA,aAAA;IACIG,QAAQ,EAAErB,cAAc,CAACO,UAAU,EAAEC,MAAM,CAAC;IAC5CM,OAAO,EAAEN,MAAM,KAAKP,IAAI,GAAGF,SAAS,GAAGe,OAAO;IAC9CQ,MAAM,EAAEX,iBAAiB,GACnB,UAACY,IAAI;MAAA,OAAAL,aAAA,CAAAA,aAAA,KAAUK,IAAI;QAAEC,KAAK,EAAED,IAAI,CAACC,KAAK,CAACC,GAAG,CAACd,iBAAiB;MAAC;IAAA,CAAE,GAC/De,SAAS;IACfC,gBAAgB,EAAEvB,YAAY;IAC9BwB,gBAAgB,EAAEhB,IAAI;IACtBiB,oBAAoB,EAAEhB;EAAI,GACvBN,UAAU,CAACE,OAAO,GAClBA,OAAO;AAElB,CAAC;AAED,OAAO,IAAMqB,eAAe,GAAG,SAAlBA,eAAeA,CACxBC,MAGC,EAC8B;EAAA,IAAAC,qBAAA,EAAAC,YAAA;EAC/B,OAAAf,aAAA,CAAAA,aAAA,KACOa,MAAM;IACTG,MAAM,EAAEhC,eAAe,CAAC6B,MAAM,CAACG,MAAM,EAAEH,MAAM,CAACI,WAAW,CAAC;IAC1DZ,IAAI,GAAAS,qBAAA,IAAAC,YAAA,GAAEF,MAAM,CAACR,IAAI,cAAAU,YAAA,uBAAXA,YAAA,CAAaT,KAAK,CAACY,IAAI,CAAC,CAAC,CAAC,cAAAJ,qBAAA,cAAAA,qBAAA,GAAI7B,WAAW;IAC/CkC,cAAc,EAAEN,MAAM,CAACG,MAAM;IAC7BI,YAAY,EAAEP,MAAM,CAACR;EAAI;AAEjC,CAAC","ignoreList":[]}

package/build/esm/react-query/impl/plain/factory.d.ts

@@ -1,2 +1,2 @@
 import type { PlainQueryDataSource } from './types';
-export declare const makePlainQueryDataSource: <TParams, TRequest, TResponse, TData, TError>(config: Omit<PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError>, "type">) => PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError>;
+export declare const makePlainQueryDataSource: <TParams, TRequest extends object, TResponse, TData, TError>(config: Omit<PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError>, "type">) => PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError>;

package/build/esm/react-query/impl/plain/factory.js.map

@@ -1 +1 @@
-{"version":3,"names":["makePlainQueryDataSource","config","_objectSpread","type"],"sources":["factory.ts"],"sourcesContent":["import type {PlainQueryDataSource} from './types';\n\nexport const makePlainQueryDataSource = <TParams, TRequest, TResponse, TData, TError>(\n    config: Omit<PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError>, 'type'>,\n): PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError> => ({\n    ...config,\n    type: 'plain',\n});\n"],"mappings":";AAEA,OAAO,IAAMA,wBAAwB,GAAG,SAA3BA,wBAAwBA,CACjCC,MAAuF;EAAA,OAAAC,aAAA,CAAAA,aAAA,KAEpFD,MAAM;IACTE,IAAI,EAAE;EAAO;AAAA,CACf","ignoreList":[]}
+{"version":3,"names":["makePlainQueryDataSource","config","_objectSpread","type"],"sources":["factory.ts"],"sourcesContent":["import type {PlainQueryDataSource} from './types';\n\nexport const makePlainQueryDataSource = <\n    TParams,\n    TRequest extends object,\n    TResponse,\n    TData,\n    TError,\n>(\n    config: Omit<PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError>, 'type'>,\n): PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError> => ({\n    ...config,\n    type: 'plain',\n});\n"],"mappings":";AAEA,OAAO,IAAMA,wBAAwB,GAAG,SAA3BA,wBAAwBA,CAOjCC,MAAuF;EAAA,OAAAC,aAAA,CAAAA,aAAA,KAEpFD,MAAM;IACTE,IAAI,EAAE;EAAO;AAAA,CACf","ignoreList":[]}

package/build/esm/react-query/impl/plain/hooks.d.ts

@@ -1,3 +1,3 @@
-import type { DataSourceContext, DataSourceOptions, DataSourceParams } from '../../../core';
+import type { DataSourceContext, DataSourceOptions, DataSourceParams, DataSourceState } from '../../../core';
 import type { AnyPlainQueryDataSource } from './types';
-export declare const usePlainQueryData: <TDataSource extends AnyPlainQueryDataSource>(context: DataSourceContext<TDataSource>, dataSource: TDataSource, params: DataSourceParams<TDataSource>, options?: DataSourceOptions<TDataSource>) => import("../../../core").DataSourceState<TDataSource>;
+export declare const usePlainQueryData: <TDataSource extends AnyPlainQueryDataSource>(context: DataSourceContext<TDataSource>, dataSource: TDataSource, params: DataSourceParams<TDataSource>, options?: Partial<DataSourceOptions<TDataSource>>) => DataSourceState<TDataSource>;

package/build/esm/react-query/impl/plain/hooks.js

@@ -1,11 +1,8 @@
-import { useMemo } from 'react';
 import { useQuery } from '@tanstack/react-query';
 import { composeOptions, transformResult } from './utils';
 export var usePlainQueryData = function usePlainQueryData(context, dataSource, params, options) {
   var composedOptions = composeOptions(context, dataSource, params, options);
   var result = useQuery(composedOptions);
-  return useMemo(function () {
-    return transformResult(result);
-  }, [result]);
+  return transformResult(result);
 };
 // #sourceMappingURL=hooks.js.map

package/build/esm/react-query/impl/plain/hooks.js.map

@@ -1 +1 @@
-{"version":3,"names":["useMemo","useQuery","composeOptions","transformResult","usePlainQueryData","context","dataSource","params","options","composedOptions","result"],"sources":["hooks.ts"],"sourcesContent":["import {useMemo} from 'react';\n\nimport {useQuery} from '@tanstack/react-query';\n\nimport type {DataSourceContext, DataSourceOptions, DataSourceParams} from '../../../core';\n\nimport type {AnyPlainQueryDataSource} from './types';\nimport {composeOptions, transformResult} from './utils';\n\nexport const usePlainQueryData = <TDataSource extends AnyPlainQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: DataSourceOptions<TDataSource>,\n) => {\n    const composedOptions = composeOptions(context, dataSource, params, options);\n    const result = useQuery(composedOptions);\n\n    return useMemo(() => transformResult(result), [result]);\n};\n"],"mappings":"AAAA,SAAQA,OAAO,QAAO,OAAO;AAE7B,SAAQC,QAAQ,QAAO,uBAAuB;AAK9C,SAAQC,cAAc,EAAEC,eAAe,QAAO,SAAS;AAEvD,OAAO,IAAMC,iBAAiB,GAAG,SAApBA,iBAAiBA,CAC1BC,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAwC,EACvC;EACD,IAAMC,eAAe,GAAGP,cAAc,CAACG,OAAO,EAAEC,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EAC5E,IAAME,MAAM,GAAGT,QAAQ,CAACQ,eAAe,CAAC;EAExC,OAAOT,OAAO,CAAC;IAAA,OAAMG,eAAe,CAACO,MAAM,CAAC;EAAA,GAAE,CAACA,MAAM,CAAC,CAAC;AAC3D,CAAC","ignoreList":[]}
+{"version":3,"names":["useQuery","composeOptions","transformResult","usePlainQueryData","context","dataSource","params","options","composedOptions","result"],"sources":["hooks.ts"],"sourcesContent":["import {useQuery} from '@tanstack/react-query';\n\nimport type {\n    DataSourceContext,\n    DataSourceOptions,\n    DataSourceParams,\n    DataSourceState,\n} from '../../../core';\n\nimport type {AnyPlainQueryDataSource} from './types';\nimport {composeOptions, transformResult} from './utils';\n\nexport const usePlainQueryData = <TDataSource extends AnyPlainQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: Partial<DataSourceOptions<TDataSource>>,\n): DataSourceState<TDataSource> => {\n    const composedOptions = composeOptions(context, dataSource, params, options);\n    const result = useQuery(composedOptions);\n\n    return transformResult(result);\n};\n"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,uBAAuB;AAU9C,SAAQC,cAAc,EAAEC,eAAe,QAAO,SAAS;AAEvD,OAAO,IAAMC,iBAAiB,GAAG,SAApBA,iBAAiBA,CAC1BC,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAiD,EAClB;EAC/B,IAAMC,eAAe,GAAGP,cAAc,CAACG,OAAO,EAAEC,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EAC5E,IAAME,MAAM,GAAGT,QAAQ,CAACQ,eAAe,CAAC;EAExC,OAAON,eAAe,CAACO,MAAM,CAAC;AAClC,CAAC","ignoreList":[]}

package/build/esm/react-query/impl/plain/types.d.ts

@@ -2,13 +2,13 @@ import type { QueryFunctionContext, QueryObserverOptions, QueryObserverResult }
 import type { Overwrite } from 'utility-types';
 import type { ActualData, DataLoaderStatus, DataSource, DataSourceKey } from '../../../core';
 import type { QueryDataSourceContext } from '../../types';
-export type PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError> = DataSource<QueryDataSourceContext, TParams, TRequest, TResponse, TData, TError, QueryObserverOptions<TResponse, TError, ActualData<TData, TResponse>, TResponse>, ResultWrapper<QueryObserverResult<ActualData<TData, TResponse>, TError>>, QueryFunctionContext<DataSourceKey, unknown>> & {
+export type PlainQueryDataSource<TParams, TRequest extends object, TResponse, TData, TError> = DataSource<QueryDataSourceContext, TParams, TRequest, TResponse, TData, TError, QueryObserverOptions<TResponse, TError, ActualData<TData, TResponse>, TResponse, DataSourceKey>, ResultWrapper<QueryObserverResult<ActualData<TData, TResponse>, TError>>, QueryFunctionContext<DataSourceKey>> & {
     type: 'plain';
 };
 export type AnyPlainQueryDataSource = PlainQueryDataSource<any, any, any, any, any>;
-type ResultWrapper<T> = T extends QueryObserverResult ? Overwrite<T, {
+type ResultWrapper<TResult> = TResult extends QueryObserverResult ? Overwrite<TResult, {
     status: DataLoaderStatus;
 }> & {
-    originalStatus: T['status'];
+    originalStatus: TResult['status'];
 } : never;
 export {};

package/build/esm/react-query/impl/plain/types.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type {\n    QueryFunctionContext,\n    QueryObserverOptions,\n    QueryObserverResult,\n} from '@tanstack/react-query';\nimport type {Overwrite} from 'utility-types';\n\nimport type {ActualData, DataLoaderStatus, DataSource, DataSourceKey} from '../../../core';\nimport type {QueryDataSourceContext} from '../../types';\n\nexport type PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError> = DataSource<\n    QueryDataSourceContext,\n    TParams,\n    TRequest,\n    TResponse,\n    TData,\n    TError,\n    QueryObserverOptions<TResponse, TError, ActualData<TData, TResponse>, TResponse>,\n    ResultWrapper<QueryObserverResult<ActualData<TData, TResponse>, TError>>,\n    QueryFunctionContext<DataSourceKey, unknown>\n> & {\n    type: 'plain';\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyPlainQueryDataSource = PlainQueryDataSource<any, any, any, any, any>;\n\ntype ResultWrapper<T> = T extends QueryObserverResult\n    ? Overwrite<T, {status: DataLoaderStatus}> & {originalStatus: T['status']}\n    : never;\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type {\n    QueryFunctionContext,\n    QueryObserverOptions,\n    QueryObserverResult,\n} from '@tanstack/react-query';\nimport type {Overwrite} from 'utility-types';\n\nimport type {ActualData, DataLoaderStatus, DataSource, DataSourceKey} from '../../../core';\nimport type {QueryDataSourceContext} from '../../types';\n\nexport type PlainQueryDataSource<\n    TParams,\n    TRequest extends object,\n    TResponse,\n    TData,\n    TError,\n> = DataSource<\n    QueryDataSourceContext,\n    TParams,\n    TRequest,\n    TResponse,\n    TData,\n    TError,\n    QueryObserverOptions<TResponse, TError, ActualData<TData, TResponse>, TResponse, DataSourceKey>,\n    ResultWrapper<QueryObserverResult<ActualData<TData, TResponse>, TError>>,\n    QueryFunctionContext<DataSourceKey>\n> & {\n    type: 'plain';\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyPlainQueryDataSource = PlainQueryDataSource<any, any, any, any, any>;\n\ntype ResultWrapper<TResult> = TResult extends QueryObserverResult\n    ? Overwrite<TResult, {status: DataLoaderStatus}> & {originalStatus: TResult['status']}\n    : never;\n"],"mappings":"","ignoreList":[]}

package/build/esm/react-query/impl/plain/utils.d.ts

@@ -1,5 +1,5 @@
-import type { QueryObserverOptions, QueryObserverResult } from '@tanstack/react-query';
-import type { DataSourceContext, DataSourceData, DataSourceError, DataSourceOptions, DataSourceParams, DataSourceResponse, DataSourceState } from '../../../core';
+import { type QueryObserverOptions, type QueryObserverResult } from '@tanstack/react-query';
+import type { DataSourceContext, DataSourceData, DataSourceError, DataSourceKey, DataSourceOptions, DataSourceParams, DataSourceResponse, DataSourceState } from '../../../core';
 import type { AnyPlainQueryDataSource } from './types';
-export declare const composeOptions: <TDataSource extends AnyPlainQueryDataSource>(context: DataSourceContext<TDataSource>, dataSource: TDataSource, params: DataSourceParams<TDataSource>, options?: DataSourceOptions<TDataSource>) => QueryObserverOptions<DataSourceResponse<TDataSource>, DataSourceError<TDataSource>, DataSourceData<TDataSource>, DataSourceResponse<TDataSource>>;
+export declare const composeOptions: <TDataSource extends AnyPlainQueryDataSource>(context: DataSourceContext<TDataSource>, dataSource: TDataSource, params: DataSourceParams<TDataSource>, options?: Partial<DataSourceOptions<TDataSource>>) => QueryObserverOptions<DataSourceResponse<TDataSource>, DataSourceError<TDataSource>, DataSourceData<TDataSource>, DataSourceResponse<TDataSource>, DataSourceKey>;
 export declare const transformResult: <TDataSource extends AnyPlainQueryDataSource>(result: QueryObserverResult<DataSourceData<TDataSource>, DataSourceError<TDataSource>>) => DataSourceState<TDataSource>;

package/build/esm/react-query/impl/plain/utils.js

@@ -1,16 +1,17 @@
 import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import { skipToken } from '@tanstack/react-query';
 import { composeFullKey, idle } from '../../../core';
 import { normalizeStatus } from '../../utils/normalizeStatus';
 export var composeOptions = function composeOptions(context, dataSource, params, options) {
   var transformParams = dataSource.transformParams;
-  return _objectSpread(_objectSpread({}, dataSource.options), {}, {
-    enabled: params !== idle,
+  var queryFn = function queryFn(fetchContext) {
+    return dataSource.fetch(context, fetchContext, transformParams ? transformParams(params) : params);
+  };
+  return _objectSpread(_objectSpread({
     queryKey: composeFullKey(dataSource, params),
-    queryFn: function queryFn(fetchContext) {
-      return dataSource.fetch(context, fetchContext, transformParams ? transformParams(params) : params);
-    },
+    queryFn: params === idle ? skipToken : queryFn,
     select: dataSource.transformResponse
-  }, options);
+  }, dataSource.options), options);
 };
 export var transformResult = function transformResult(result) {
   return _objectSpread(_objectSpread({}, result), {}, {

package/build/esm/react-query/impl/plain/utils.js.map

@@ -1 +1 @@
-{"version":3,"names":["composeFullKey","idle","normalizeStatus","composeOptions","context","dataSource","params","options","transformParams","_objectSpread","enabled","queryKey","queryFn","fetchContext","fetch","select","transformResponse","transformResult","result","status","fetchStatus","originalStatus"],"sources":["utils.ts"],"sourcesContent":["import type {\n    QueryFunctionContext,\n    QueryObserverOptions,\n    QueryObserverResult,\n} from '@tanstack/react-query';\n\nimport {composeFullKey, idle} from '../../../core';\nimport type {\n    DataSourceContext,\n    DataSourceData,\n    DataSourceError,\n    DataSourceKey,\n    DataSourceOptions,\n    DataSourceParams,\n    DataSourceResponse,\n    DataSourceState,\n} from '../../../core';\nimport {normalizeStatus} from '../../utils/normalizeStatus';\n\nimport type {AnyPlainQueryDataSource} from './types';\n\nexport const composeOptions = <TDataSource extends AnyPlainQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: DataSourceOptions<TDataSource>,\n): QueryObserverOptions<\n    DataSourceResponse<TDataSource>,\n    DataSourceError<TDataSource>,\n    DataSourceData<TDataSource>,\n    DataSourceResponse<TDataSource>\n> => {\n    const {transformParams} = dataSource;\n\n    return {\n        ...dataSource.options,\n        enabled: params !== idle,\n        queryKey: composeFullKey(dataSource, params),\n        queryFn: (fetchContext: QueryFunctionContext<DataSourceKey, unknown>) =>\n            dataSource.fetch(\n                context,\n                fetchContext,\n                transformParams ? transformParams(params) : params,\n            ),\n        select: dataSource.transformResponse,\n        ...options,\n    };\n};\n\nexport const transformResult = <TDataSource extends AnyPlainQueryDataSource>(\n    result: QueryObserverResult<DataSourceData<TDataSource>, DataSourceError<TDataSource>>,\n) => {\n    return {\n        ...result,\n        status: normalizeStatus(result.status, result.fetchStatus),\n        originalStatus: result.status,\n    } as DataSourceState<TDataSource>;\n};\n"],"mappings":";AAMA,SAAQA,cAAc,EAAEC,IAAI,QAAO,eAAe;AAWlD,SAAQC,eAAe,QAAO,6BAA6B;AAI3D,OAAO,IAAMC,cAAc,GAAG,SAAjBA,cAAcA,CACvBC,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAwC,EAMvC;EACD,IAAOC,eAAe,GAAIH,UAAU,CAA7BG,eAAe;EAEtB,OAAAC,aAAA,CAAAA,aAAA,KACOJ,UAAU,CAACE,OAAO;IACrBG,OAAO,EAAEJ,MAAM,KAAKL,IAAI;IACxBU,QAAQ,EAAEX,cAAc,CAACK,UAAU,EAAEC,MAAM,CAAC;IAC5CM,OAAO,EAAE,SAATA,OAAOA,CAAGC,YAA0D;MAAA,OAChER,UAAU,CAACS,KAAK,CACZV,OAAO,EACPS,YAAY,EACZL,eAAe,GAAGA,eAAe,CAACF,MAAM,CAAC,GAAGA,MAChD,CAAC;IAAA;IACLS,MAAM,EAAEV,UAAU,CAACW;EAAiB,GACjCT,OAAO;AAElB,CAAC;AAED,OAAO,IAAMU,eAAe,GAAG,SAAlBA,eAAeA,CACxBC,MAAsF,EACrF;EACD,OAAAT,aAAA,CAAAA,aAAA,KACOS,MAAM;IACTC,MAAM,EAAEjB,eAAe,CAACgB,MAAM,CAACC,MAAM,EAAED,MAAM,CAACE,WAAW,CAAC;IAC1DC,cAAc,EAAEH,MAAM,CAACC;EAAM;AAErC,CAAC","ignoreList":[]}
+{"version":3,"names":["skipToken","composeFullKey","idle","normalizeStatus","composeOptions","context","dataSource","params","options","transformParams","queryFn","fetchContext","fetch","_objectSpread","queryKey","select","transformResponse","transformResult","result","status","fetchStatus","originalStatus"],"sources":["utils.ts"],"sourcesContent":["import {\n    type QueryFunctionContext,\n    type QueryObserverOptions,\n    type QueryObserverResult,\n    skipToken,\n} from '@tanstack/react-query';\n\nimport {composeFullKey, idle} from '../../../core';\nimport type {\n    DataSourceContext,\n    DataSourceData,\n    DataSourceError,\n    DataSourceKey,\n    DataSourceOptions,\n    DataSourceParams,\n    DataSourceResponse,\n    DataSourceState,\n} from '../../../core';\nimport {normalizeStatus} from '../../utils/normalizeStatus';\n\nimport type {AnyPlainQueryDataSource} from './types';\n\nexport const composeOptions = <TDataSource extends AnyPlainQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: Partial<DataSourceOptions<TDataSource>>,\n): QueryObserverOptions<\n    DataSourceResponse<TDataSource>,\n    DataSourceError<TDataSource>,\n    DataSourceData<TDataSource>,\n    DataSourceResponse<TDataSource>,\n    DataSourceKey\n> => {\n    const {transformParams} = dataSource;\n\n    const queryFn = (\n        fetchContext: QueryFunctionContext<DataSourceKey>,\n    ): DataSourceResponse<TDataSource> | Promise<DataSourceResponse<TDataSource>> => {\n        return dataSource.fetch(\n            context,\n            fetchContext,\n            transformParams ? transformParams(params) : params,\n        );\n    };\n\n    return {\n        queryKey: composeFullKey(dataSource, params),\n        queryFn: params === idle ? skipToken : queryFn,\n        select: dataSource.transformResponse,\n        ...dataSource.options,\n        ...options,\n    };\n};\n\nexport const transformResult = <TDataSource extends AnyPlainQueryDataSource>(\n    result: QueryObserverResult<DataSourceData<TDataSource>, DataSourceError<TDataSource>>,\n): DataSourceState<TDataSource> => {\n    return {\n        ...result,\n        status: normalizeStatus(result.status, result.fetchStatus),\n        originalStatus: result.status,\n    } as DataSourceState<TDataSource>;\n};\n"],"mappings":";AAAA,SAIIA,SAAS,QACN,uBAAuB;AAE9B,SAAQC,cAAc,EAAEC,IAAI,QAAO,eAAe;AAWlD,SAAQC,eAAe,QAAO,6BAA6B;AAI3D,OAAO,IAAMC,cAAc,GAAG,SAAjBA,cAAcA,CACvBC,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAiD,EAOhD;EACD,IAAOC,eAAe,GAAIH,UAAU,CAA7BG,eAAe;EAEtB,IAAMC,OAAO,GAAG,SAAVA,OAAOA,CACTC,YAAiD,EAC4B;IAC7E,OAAOL,UAAU,CAACM,KAAK,CACnBP,OAAO,EACPM,YAAY,EACZF,eAAe,GAAGA,eAAe,CAACF,MAAM,CAAC,GAAGA,MAChD,CAAC;EACL,CAAC;EAED,OAAAM,aAAA,CAAAA,aAAA;IACIC,QAAQ,EAAEb,cAAc,CAACK,UAAU,EAAEC,MAAM,CAAC;IAC5CG,OAAO,EAAEH,MAAM,KAAKL,IAAI,GAAGF,SAAS,GAAGU,OAAO;IAC9CK,MAAM,EAAET,UAAU,CAACU;EAAiB,GACjCV,UAAU,CAACE,OAAO,GAClBA,OAAO;AAElB,CAAC;AAED,OAAO,IAAMS,eAAe,GAAG,SAAlBA,eAAeA,CACxBC,MAAsF,EACvD;EAC/B,OAAAL,aAAA,CAAAA,aAAA,KACOK,MAAM;IACTC,MAAM,EAAEhB,eAAe,CAACe,MAAM,CAACC,MAAM,EAAED,MAAM,CAACE,WAAW,CAAC;IAC1DC,cAAc,EAAEH,MAAM,CAACC;EAAM;AAErC,CAAC","ignoreList":[]}

package/build/esm/react-query/utils/normalizeStatus.js

@@ -1,5 +1,8 @@
 export var normalizeStatus = function normalizeStatus(status, fetchStatus) {
-  if (status === 'loading' && fetchStatus === 'idle') {
+  if (status === 'pending') {
+    if (fetchStatus === 'fetching') {
+      return 'loading';
+    }
     return 'success';
   }
   return status;

package/build/esm/react-query/utils/normalizeStatus.js.map

@@ -1 +1 @@
-{"version":3,"names":["normalizeStatus","status","fetchStatus"],"sources":["normalizeStatus.ts"],"sourcesContent":["import type {FetchStatus, QueryStatus} from '@tanstack/react-query';\n\nimport type {DataLoaderStatus} from '../../core';\n\nexport const normalizeStatus = (\n    status: QueryStatus,\n    fetchStatus: FetchStatus,\n): DataLoaderStatus => {\n    if (status === 'loading' && fetchStatus === 'idle') {\n        return 'success';\n    }\n\n    return status;\n};\n"],"mappings":"AAIA,OAAO,IAAMA,eAAe,GAAG,SAAlBA,eAAeA,CACxBC,MAAmB,EACnBC,WAAwB,EACL;EACnB,IAAID,MAAM,KAAK,SAAS,IAAIC,WAAW,KAAK,MAAM,EAAE;IAChD,OAAO,SAAS;EACpB;EAEA,OAAOD,MAAM;AACjB,CAAC","ignoreList":[]}
+{"version":3,"names":["normalizeStatus","status","fetchStatus"],"sources":["normalizeStatus.ts"],"sourcesContent":["import type {FetchStatus, QueryStatus} from '@tanstack/react-query';\n\nimport type {DataLoaderStatus} from '../../core';\n\nexport const normalizeStatus = (\n    status: QueryStatus,\n    fetchStatus: FetchStatus,\n): DataLoaderStatus => {\n    if (status === 'pending') {\n        if (fetchStatus === 'fetching') {\n            return 'loading';\n        }\n\n        return 'success';\n    }\n\n    return status;\n};\n"],"mappings":"AAIA,OAAO,IAAMA,eAAe,GAAG,SAAlBA,eAAeA,CACxBC,MAAmB,EACnBC,WAAwB,EACL;EACnB,IAAID,MAAM,KAAK,SAAS,EAAE;IACtB,IAAIC,WAAW,KAAK,UAAU,EAAE;MAC5B,OAAO,SAAS;IACpB;IAEA,OAAO,SAAS;EACpB;EAEA,OAAOD,MAAM;AACjB,CAAC","ignoreList":[]}

package/build/esm/react-query/utils/notReachable.d.ts

@@ -0,0 +1 @@
+export declare const notReachable: (value: never, message?: string) => never;

package/build/esm/react-query/utils/notReachable.js

@@ -0,0 +1,4 @@
+export var notReachable = function notReachable(value, message) {
+  throw new Error(message || "Not reachable state: ".concat(value));
+};
+// #sourceMappingURL=notReachable.js.map

package/build/esm/react-query/utils/notReachable.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["notReachable","value","message","Error","concat"],"sources":["notReachable.ts"],"sourcesContent":["export const notReachable = (value: never, message?: string): never => {\n    throw new Error(message || `Not reachable state: ${value}`);\n};\n"],"mappings":"AAAA,OAAO,IAAMA,YAAY,GAAG,SAAfA,YAAYA,CAAIC,KAAY,EAAEC,OAAgB,EAAY;EACnE,MAAM,IAAIC,KAAK,CAACD,OAAO,4BAAAE,MAAA,CAA4BH,KAAK,CAAE,CAAC;AAC/D,CAAC","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/data-source",
-  "version": "0.2.1",
+  "version": "0.3.0-alpha.0",
   "description": "A wrapper around data fetching",
   "keywords": [
     "data-fetching",
@@ -53,7 +53,7 @@
     "@gravity-ui/prettier-config": "^1.1.0",
     "@gravity-ui/tsconfig": "^1.0.0",
     "@swc/jest": "^0.2.36",
-    "@tanstack/react-query": "^4.36.1",
+    "@tanstack/react-query": "^5.51.23",
     "@types/jest": "^29.5.12",
     "@types/react": "^18.3.3",
     "eslint": "^8.57.0",
@@ -63,7 +63,7 @@
     "react": "^18.3.1"
   },
   "peerDependencies": {
-    "@tanstack/react-query": "^4.0.0",
-    "react": "^16.0.0 || ^17.0.0 || ^18.0.0"
+    "@tanstack/react-query": "^5.0.0",
+    "react": "^18.0.0"
   }
 }