@gravity-ui/data-source 0.3.0 → 0.5.0

package/build/cjs/core/index.d.ts

@@ -1,6 +1,7 @@
 export type { DataSourceKey, DataSourceTag, DataSource, AnyDataSource, DataSourceContext, DataSourceParams, DataSourceRequest, DataSourceResponse, DataSourceData, DataSourceError, DataSourceOptions, DataSourceState, DataSourceFetchContext, ActualParams, ActualData, } from './types/DataSource';
 export type { DataManager } from './types/DataManger';
 export type { DataLoaderStatus } from './types/DataLoaderStatus';
+export type { InvalidateRepeatOptions, InvalidateOptions } from './types/DataManagerOptions';
 export { idle } from './constants';
 export { composeKey } from './utils/composeKey';
 export { composeFullKey } from './utils/composeFullKey';

package/build/cjs/core/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_constants","require","_composeKey","_composeFullKey","_getError","_getStatus","_hasTag","_mergeStatuses","_skipContext","_withCancellation"],"sources":["index.ts"],"sourcesContent":["export type {\n    DataSourceKey,\n    DataSourceTag,\n    DataSource,\n    AnyDataSource,\n    DataSourceContext,\n    DataSourceParams,\n    DataSourceRequest,\n    DataSourceResponse,\n    DataSourceData,\n    DataSourceError,\n    DataSourceOptions,\n    DataSourceState,\n    DataSourceFetchContext,\n    ActualParams,\n    ActualData,\n} from './types/DataSource';\nexport type {DataManager} from './types/DataManger';\nexport type {DataLoaderStatus} from './types/DataLoaderStatus';\n\nexport {idle} from './constants';\n\nexport {composeKey} from './utils/composeKey';\nexport {composeFullKey} from './utils/composeFullKey';\nexport {getError} from './utils/getError';\nexport {getStatus} from './utils/getStatus';\nexport {hasTag} from './utils/hasTag';\nexport {mergeStatuses} from './utils/mergeStatuses';\nexport {skipContext} from './utils/skipContext';\nexport type {Cancellable} from './utils/withCancellation';\nexport {isCancellable, isAbortable, withCancellation} from './utils/withCancellation';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoBA,IAAAA,UAAA,GAAAC,OAAA;AAEA,IAAAC,WAAA,GAAAD,OAAA;AACA,IAAAE,eAAA,GAAAF,OAAA;AACA,IAAAG,SAAA,GAAAH,OAAA;AACA,IAAAI,UAAA,GAAAJ,OAAA;AACA,IAAAK,OAAA,GAAAL,OAAA;AACA,IAAAM,cAAA,GAAAN,OAAA;AACA,IAAAO,YAAA,GAAAP,OAAA;AAEA,IAAAQ,iBAAA,GAAAR,OAAA","ignoreList":[]}
+{"version":3,"names":["_constants","require","_composeKey","_composeFullKey","_getError","_getStatus","_hasTag","_mergeStatuses","_skipContext","_withCancellation"],"sources":["index.ts"],"sourcesContent":["export type {\n    DataSourceKey,\n    DataSourceTag,\n    DataSource,\n    AnyDataSource,\n    DataSourceContext,\n    DataSourceParams,\n    DataSourceRequest,\n    DataSourceResponse,\n    DataSourceData,\n    DataSourceError,\n    DataSourceOptions,\n    DataSourceState,\n    DataSourceFetchContext,\n    ActualParams,\n    ActualData,\n} from './types/DataSource';\nexport type {DataManager} from './types/DataManger';\nexport type {DataLoaderStatus} from './types/DataLoaderStatus';\nexport type {InvalidateRepeatOptions, InvalidateOptions} from './types/DataManagerOptions';\n\nexport {idle} from './constants';\n\nexport {composeKey} from './utils/composeKey';\nexport {composeFullKey} from './utils/composeFullKey';\nexport {getError} from './utils/getError';\nexport {getStatus} from './utils/getStatus';\nexport {hasTag} from './utils/hasTag';\nexport {mergeStatuses} from './utils/mergeStatuses';\nexport {skipContext} from './utils/skipContext';\nexport type {Cancellable} from './utils/withCancellation';\nexport {isCancellable, isAbortable, withCancellation} from './utils/withCancellation';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,IAAAA,UAAA,GAAAC,OAAA;AAEA,IAAAC,WAAA,GAAAD,OAAA;AACA,IAAAE,eAAA,GAAAF,OAAA;AACA,IAAAG,SAAA,GAAAH,OAAA;AACA,IAAAI,UAAA,GAAAJ,OAAA;AACA,IAAAK,OAAA,GAAAL,OAAA;AACA,IAAAM,cAAA,GAAAN,OAAA;AACA,IAAAO,YAAA,GAAAP,OAAA;AAEA,IAAAQ,iBAAA,GAAAR,OAAA","ignoreList":[]}

package/build/cjs/core/types/DataManagerOptions.d.ts

@@ -0,0 +1,10 @@
+export interface InvalidateRepeatOptions {
+    interval: number;
+    /**
+     * Number of repeated calls, not counting the first one
+     */
+    count: number;
+}
+export interface InvalidateOptions {
+    repeat?: InvalidateRepeatOptions;
+}

package/build/cjs/core/types/DataManagerOptions.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+// #sourceMappingURL=DataManagerOptions.js.map

package/build/cjs/core/types/DataManagerOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["DataManagerOptions.ts"],"sourcesContent":["export interface InvalidateRepeatOptions {\n    interval: number;\n    /**\n     * Number of repeated calls, not counting the first one\n     */\n    count: number;\n}\n\nexport interface InvalidateOptions {\n    repeat?: InvalidateRepeatOptions;\n}\n"],"mappings":"","ignoreList":[]}

package/build/cjs/core/types/DataManger.d.ts

@@ -1,10 +1,11 @@
+import type { InvalidateOptions } from './DataManagerOptions';
 import type { AnyDataSource, DataSourceParams, DataSourceTag } from './DataSource';
 export interface DataManager {
-    invalidateTag(tag: DataSourceTag): Promise<void>;
-    invalidateTags(tags: DataSourceTag[]): Promise<void>;
-    invalidateSource<TDataSource extends AnyDataSource>(dataSource: TDataSource): Promise<void>;
+    invalidateTag(tag: DataSourceTag, invalidateOptions?: InvalidateOptions): Promise<void>;
+    invalidateTags(tags: DataSourceTag[], invalidateOptions?: InvalidateOptions): Promise<void>;
+    invalidateSource<TDataSource extends AnyDataSource>(dataSource: TDataSource, invalidateOptions?: InvalidateOptions): Promise<void>;
     resetSource<TDataSource extends AnyDataSource>(dataSource: TDataSource): Promise<void>;
-    invalidateParams<TDataSource extends AnyDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>): Promise<void>;
+    invalidateParams<TDataSource extends AnyDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>, invalidateOptions?: InvalidateOptions): Promise<void>;
     resetParams<TDataSource extends AnyDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>): Promise<void>;
-    invalidateSourceTags<TDataSource extends AnyDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>): Promise<void>;
+    invalidateSourceTags<TDataSource extends AnyDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>, invalidateOptions?: InvalidateOptions): Promise<void>;
 }

package/build/cjs/core/types/DataManger.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["DataManger.ts"],"sourcesContent":["import type {AnyDataSource, DataSourceParams, DataSourceTag} from './DataSource';\n\nexport interface DataManager {\n    invalidateTag(tag: DataSourceTag): Promise<void>;\n    invalidateTags(tags: DataSourceTag[]): Promise<void>;\n\n    invalidateSource<TDataSource extends AnyDataSource>(dataSource: TDataSource): Promise<void>;\n\n    resetSource<TDataSource extends AnyDataSource>(dataSource: TDataSource): Promise<void>;\n\n    invalidateParams<TDataSource extends AnyDataSource>(\n        dataSource: TDataSource,\n        params: DataSourceParams<TDataSource>,\n    ): Promise<void>;\n\n    resetParams<TDataSource extends AnyDataSource>(\n        dataSource: TDataSource,\n        params: DataSourceParams<TDataSource>,\n    ): Promise<void>;\n\n    invalidateSourceTags<TDataSource extends AnyDataSource>(\n        dataSource: TDataSource,\n        params: DataSourceParams<TDataSource>,\n    ): Promise<void>;\n}\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["DataManger.ts"],"sourcesContent":["import type {InvalidateOptions} from './DataManagerOptions';\nimport type {AnyDataSource, DataSourceParams, DataSourceTag} from './DataSource';\n\nexport interface DataManager {\n    invalidateTag(tag: DataSourceTag, invalidateOptions?: InvalidateOptions): Promise<void>;\n    invalidateTags(tags: DataSourceTag[], invalidateOptions?: InvalidateOptions): Promise<void>;\n\n    invalidateSource<TDataSource extends AnyDataSource>(\n        dataSource: TDataSource,\n        invalidateOptions?: InvalidateOptions,\n    ): Promise<void>;\n\n    resetSource<TDataSource extends AnyDataSource>(dataSource: TDataSource): Promise<void>;\n\n    invalidateParams<TDataSource extends AnyDataSource>(\n        dataSource: TDataSource,\n        params: DataSourceParams<TDataSource>,\n        invalidateOptions?: InvalidateOptions,\n    ): Promise<void>;\n\n    resetParams<TDataSource extends AnyDataSource>(\n        dataSource: TDataSource,\n        params: DataSourceParams<TDataSource>,\n    ): Promise<void>;\n\n    invalidateSourceTags<TDataSource extends AnyDataSource>(\n        dataSource: TDataSource,\n        params: DataSourceParams<TDataSource>,\n        invalidateOptions?: InvalidateOptions,\n    ): Promise<void>;\n}\n"],"mappings":"","ignoreList":[]}

package/build/cjs/react-query/ClientDataManager.d.ts

@@ -1,15 +1,18 @@
 import type { QueryClientConfig } from '@tanstack/react-query';
 import { QueryClient } from '@tanstack/react-query';
 import { type AnyDataSource, type DataManager, type DataSourceParams, type DataSourceTag } from '../core';
+import type { InvalidateOptions } from '../core/types/DataManagerOptions';
 export type ClientDataManagerConfig = QueryClientConfig;
 export declare class ClientDataManager implements DataManager {
     readonly queryClient: QueryClient;
     constructor(conifg?: ClientDataManagerConfig);
-    invalidateTag(tag: DataSourceTag): Promise<void>;
-    invalidateTags(tags: DataSourceTag[]): Promise<void>;
-    invalidateSource<TDataSource extends AnyDataSource>(dataSource: TDataSource): Promise<void>;
+    invalidateTag(tag: DataSourceTag, invalidateOptions?: InvalidateOptions): Promise<void>;
+    invalidateTags(tags: DataSourceTag[], invalidateOptions?: InvalidateOptions): Promise<void>;
+    invalidateSource<TDataSource extends AnyDataSource>(dataSource: TDataSource, invalidateOptions?: InvalidateOptions): Promise<void>;
     resetSource<TDataSource extends AnyDataSource>(dataSource: TDataSource): Promise<void>;
-    invalidateParams<TDataSource extends AnyDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>): Promise<void>;
+    invalidateParams<TDataSource extends AnyDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>, invalidateOptions?: InvalidateOptions): Promise<void>;
     resetParams<TDataSource extends AnyDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>): Promise<void>;
-    invalidateSourceTags<TDataSource extends AnyDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>): Promise<void>;
+    invalidateSourceTags<TDataSource extends AnyDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>, invalidateOptions?: InvalidateOptions): Promise<void>;
+    private invalidateQueries;
+    private repeatInvalidate;
 }

package/build/cjs/react-query/ClientDataManager.js

@@ -29,33 +29,33 @@ var ClientDataManager = exports.ClientDataManager = /*#__PURE__*/function () {
   }
   return (0, _createClass2.default)(ClientDataManager, [{
     key: "invalidateTag",
-    value: function invalidateTag(tag) {
-      return this.queryClient.invalidateQueries({
+    value: function invalidateTag(tag, invalidateOptions) {
+      return this.invalidateQueries({
         predicate: function predicate(_ref) {
           var queryKey = _ref.queryKey;
           return (0, _core.hasTag)(queryKey, tag);
         }
-      });
+      }, invalidateOptions);
     }
   }, {
     key: "invalidateTags",
-    value: function invalidateTags(tags) {
-      return this.queryClient.invalidateQueries({
+    value: function invalidateTags(tags, invalidateOptions) {
+      return this.invalidateQueries({
         predicate: function predicate(_ref2) {
           var queryKey = _ref2.queryKey;
           return tags.every(function (tag) {
             return (0, _core.hasTag)(queryKey, tag);
           });
         }
-      });
+      }, invalidateOptions);
     }
   }, {
     key: "invalidateSource",
-    value: function invalidateSource(dataSource) {
-      return this.queryClient.invalidateQueries({
+    value: function invalidateSource(dataSource, invalidateOptions) {
+      return this.invalidateQueries({
         // First element is a data source name
         queryKey: [dataSource.name]
-      });
+      }, invalidateOptions);
     }
   }, {
     key: "resetSource",
@@ -67,11 +67,11 @@ var ClientDataManager = exports.ClientDataManager = /*#__PURE__*/function () {
     }
   }, {
     key: "invalidateParams",
-    value: function invalidateParams(dataSource, params) {
-      return this.queryClient.invalidateQueries({
+    value: function invalidateParams(dataSource, params, invalidateOptions) {
+      return this.invalidateQueries({
         queryKey: (0, _core.composeFullKey)(dataSource, params),
         exact: true
-      });
+      }, invalidateOptions);
     }
   }, {
     key: "resetParams",
@@ -83,11 +83,35 @@ var ClientDataManager = exports.ClientDataManager = /*#__PURE__*/function () {
     }
   }, {
     key: "invalidateSourceTags",
-    value: function invalidateSourceTags(dataSource, params) {
-      return this.queryClient.invalidateQueries({
+    value: function invalidateSourceTags(dataSource, params, invalidateOptions) {
+      return this.invalidateQueries({
         // Last element is a full key
         queryKey: (0, _core.composeFullKey)(dataSource, params).slice(0, -1)
-      });
+      }, invalidateOptions);
+    }
+  }, {
+    key: "invalidateQueries",
+    value: function invalidateQueries(filters, invalidateOptions) {
+      var _this = this;
+      var _ref3 = invalidateOptions || {},
+        repeat = _ref3.repeat;
+      var invalidate = function invalidate() {
+        return _this.queryClient.invalidateQueries(filters);
+      };
+      this.repeatInvalidate(invalidate, repeat);
+      return invalidate();
+    }
+  }, {
+    key: "repeatInvalidate",
+    value: function repeatInvalidate(invalidate, repeat) {
+      if (!repeat) {
+        return;
+      }
+      var interval = repeat.interval,
+        count = repeat.count;
+      for (var i = 1; i <= count; i++) {
+        setTimeout(invalidate, interval * i);
+      }
     }
   }]);
 }();

package/build/cjs/react-query/ClientDataManager.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactQuery","require","_core","_interopRequireDefault","e","__esModule","default","ClientDataManager","exports","_conifg$defaultOption","_conifg$defaultOption2","conifg","arguments","length","undefined","_classCallCheck","queryClient","QueryClient","_objectSpread","defaultOptions","queries","networkMode","mutations","_createClass","key","value","invalidateTag","tag","invalidateQueries","predicate","_ref","queryKey","hasTag","invalidateTags","tags","_ref2","every","invalidateSource","dataSource","name","resetSource","resetQueries","invalidateParams","params","composeFullKey","exact","resetParams","invalidateSourceTags","slice"],"sources":["ClientDataManager.ts"],"sourcesContent":["import type {QueryClientConfig} from '@tanstack/react-query';\nimport {QueryClient} from '@tanstack/react-query';\n\nimport {\n    type AnyDataSource,\n    type DataManager,\n    type DataSourceParams,\n    type DataSourceTag,\n    composeFullKey,\n    hasTag,\n} from '../core';\n\nexport type ClientDataManagerConfig = QueryClientConfig;\n\nexport class ClientDataManager implements DataManager {\n    readonly queryClient: QueryClient;\n\n    constructor(conifg: ClientDataManagerConfig = {}) {\n        this.queryClient = new QueryClient({\n            ...conifg,\n            defaultOptions: {\n                ...conifg.defaultOptions,\n                queries: {\n                    networkMode: 'always',\n                    ...conifg.defaultOptions?.queries,\n                },\n                mutations: {\n                    networkMode: 'always',\n                    ...conifg.defaultOptions?.mutations,\n                },\n            },\n        });\n    }\n\n    invalidateTag(tag: DataSourceTag) {\n        return this.queryClient.invalidateQueries({\n            predicate: ({queryKey}) => hasTag(queryKey, tag),\n        });\n    }\n\n    invalidateTags(tags: DataSourceTag[]) {\n        return this.queryClient.invalidateQueries({\n            predicate: ({queryKey}) => tags.every((tag) => hasTag(queryKey, tag)),\n        });\n    }\n\n    invalidateSource<TDataSource extends AnyDataSource>(dataSource: TDataSource) {\n        return this.queryClient.invalidateQueries({\n            // First element is a data source name\n            queryKey: [dataSource.name],\n        });\n    }\n\n    resetSource<TDataSource extends AnyDataSource>(dataSource: TDataSource) {\n        return this.queryClient.resetQueries({\n            // First element is a data source name\n            queryKey: [dataSource.name],\n        });\n    }\n\n    invalidateParams<TDataSource extends AnyDataSource>(\n        dataSource: TDataSource,\n        params: DataSourceParams<TDataSource>,\n    ) {\n        return this.queryClient.invalidateQueries({\n            queryKey: composeFullKey(dataSource, params),\n            exact: true,\n        });\n    }\n\n    resetParams<TDataSource extends AnyDataSource>(\n        dataSource: TDataSource,\n        params: DataSourceParams<TDataSource>,\n    ) {\n        return this.queryClient.resetQueries({\n            queryKey: composeFullKey(dataSource, params),\n            exact: true,\n        });\n    }\n\n    invalidateSourceTags<TDataSource extends AnyDataSource>(\n        dataSource: TDataSource,\n        params: DataSourceParams<TDataSource>,\n    ) {\n        return this.queryClient.invalidateQueries({\n            // Last element is a full key\n            queryKey: composeFullKey(dataSource, params).slice(0, -1),\n        });\n    }\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_reactQuery","require","_core","_interopRequireDefault","e","__esModule","default","ClientDataManager","exports","_conifg$defaultOption","_conifg$defaultOption2","conifg","arguments","length","undefined","_classCallCheck","queryClient","QueryClient","_objectSpread","defaultOptions","queries","networkMode","mutations","_createClass","key","value","invalidateTag","tag","invalidateOptions","invalidateQueries","predicate","_ref","queryKey","hasTag","invalidateTags","tags","_ref2","every","invalidateSource","dataSource","name","resetSource","resetQueries","invalidateParams","params","composeFullKey","exact","resetParams","invalidateSourceTags","slice","filters","_this","_ref3","repeat","invalidate","repeatInvalidate","interval","count","i","setTimeout"],"sources":["ClientDataManager.ts"],"sourcesContent":["import type {InvalidateQueryFilters, QueryClientConfig} from '@tanstack/react-query';\nimport {QueryClient} from '@tanstack/react-query';\n\nimport {\n    type AnyDataSource,\n    type DataManager,\n    type DataSourceParams,\n    type DataSourceTag,\n    composeFullKey,\n    hasTag,\n} from '../core';\nimport type {InvalidateOptions, InvalidateRepeatOptions} from '../core/types/DataManagerOptions';\n\nexport type ClientDataManagerConfig = QueryClientConfig;\n\nexport class ClientDataManager implements DataManager {\n    readonly queryClient: QueryClient;\n\n    constructor(conifg: ClientDataManagerConfig = {}) {\n        this.queryClient = new QueryClient({\n            ...conifg,\n            defaultOptions: {\n                ...conifg.defaultOptions,\n                queries: {\n                    networkMode: 'always',\n                    ...conifg.defaultOptions?.queries,\n                },\n                mutations: {\n                    networkMode: 'always',\n                    ...conifg.defaultOptions?.mutations,\n                },\n            },\n        });\n    }\n\n    invalidateTag(tag: DataSourceTag, invalidateOptions?: InvalidateOptions) {\n        return this.invalidateQueries(\n            {\n                predicate: ({queryKey}) => hasTag(queryKey, tag),\n            },\n            invalidateOptions,\n        );\n    }\n\n    invalidateTags(tags: DataSourceTag[], invalidateOptions?: InvalidateOptions) {\n        return this.invalidateQueries(\n            {\n                predicate: ({queryKey}) => tags.every((tag) => hasTag(queryKey, tag)),\n            },\n            invalidateOptions,\n        );\n    }\n\n    invalidateSource<TDataSource extends AnyDataSource>(\n        dataSource: TDataSource,\n        invalidateOptions?: InvalidateOptions,\n    ) {\n        return this.invalidateQueries(\n            {\n                // First element is a data source name\n                queryKey: [dataSource.name],\n            },\n            invalidateOptions,\n        );\n    }\n\n    resetSource<TDataSource extends AnyDataSource>(dataSource: TDataSource) {\n        return this.queryClient.resetQueries({\n            // First element is a data source name\n            queryKey: [dataSource.name],\n        });\n    }\n\n    invalidateParams<TDataSource extends AnyDataSource>(\n        dataSource: TDataSource,\n        params: DataSourceParams<TDataSource>,\n        invalidateOptions?: InvalidateOptions,\n    ) {\n        return this.invalidateQueries(\n            {\n                queryKey: composeFullKey(dataSource, params),\n                exact: true,\n            },\n            invalidateOptions,\n        );\n    }\n\n    resetParams<TDataSource extends AnyDataSource>(\n        dataSource: TDataSource,\n        params: DataSourceParams<TDataSource>,\n    ) {\n        return this.queryClient.resetQueries({\n            queryKey: composeFullKey(dataSource, params),\n            exact: true,\n        });\n    }\n\n    invalidateSourceTags<TDataSource extends AnyDataSource>(\n        dataSource: TDataSource,\n        params: DataSourceParams<TDataSource>,\n        invalidateOptions?: InvalidateOptions,\n    ) {\n        return this.invalidateQueries(\n            {\n                // Last element is a full key\n                queryKey: composeFullKey(dataSource, params).slice(0, -1),\n            },\n            invalidateOptions,\n        );\n    }\n\n    private invalidateQueries(\n        filters: InvalidateQueryFilters,\n        invalidateOptions?: InvalidateOptions,\n    ) {\n        const {repeat} = invalidateOptions || {};\n\n        const invalidate = () => this.queryClient.invalidateQueries(filters);\n\n        this.repeatInvalidate(invalidate, repeat);\n\n        return invalidate();\n    }\n\n    private repeatInvalidate(invalidate: () => Promise<void>, repeat?: InvalidateRepeatOptions) {\n        if (!repeat) {\n            return;\n        }\n        const {interval, count} = repeat;\n\n        for (let i = 1; i <= count; i++) {\n            setTimeout(invalidate, interval * i);\n        }\n    }\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -1 +1 @@
-{"version":3,"names":["_hooks","require","_hooks2","_notReachable","_useQueryContext","useQueryData","exports","dataSource","params","options","context","useQueryContext","type","state","usePlainQueryData","useInfiniteQueryData","notReachable","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,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,OAAA,GAAAD,OAAA;AAEA,IAAAE,aAAA,GAAAF,OAAA;AAEA,IAAAG,gBAAA,GAAAH,OAAA;AAEO,IAAMI,YAAY,GAAAC,OAAA,CAAAD,YAAA,GAAG,SAAfA,YAAYA,CACrBE,UAAuB,EACvBC,MAAqC,EACrCC,OAAiD,EAClB;EAC/B,IAAMC,OAAO,GAAG,IAAAC,gCAAe,EAAC,CAAC;EAEjC,IAAMC,IAAI,GAAGL,UAAU,CAACK,IAAI;EAC5B,IAAIC,KAAsD;;EAE1D;EACA,IAAID,IAAI,KAAK,OAAO,EAAE;IAClB;IACAC,KAAK,GAAG,IAAAC,yBAAiB,EAACJ,OAAO,EAAEH,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EACnE,CAAC,MAAM,IAAIG,IAAI,KAAK,UAAU,EAAE;IAC5B;IACAC,KAAK,GAAG,IAAAE,2BAAoB,EACxBL,OAAO,EACPH,UAAU,EACVC,MAAM;IACN;IACAC,OACJ,CAAC;EACL,CAAC,MAAM;IACH,OAAO,IAAAO,0BAAY,EAACJ,IAAI,sDAAAK,MAAA,CAAsDL,IAAI,CAAE,CAAC;EACzF;EAEA,OAAOC,KAAK;AAChB,CAAC","ignoreList":[]}
+{"version":3,"names":["_hooks","require","_hooks2","_notReachable","_useQueryContext","useQueryData","exports","dataSource","params","options","context","useQueryContext","type","state","usePlainQueryData","useInfiniteQueryData","notReachable","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 {AnyPlainQueryDataSource} from '../impl/plain/types';\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(\n            context,\n            dataSource,\n            params,\n            options as Partial<DataSourceOptions<AnyPlainQueryDataSource>> | undefined,\n        );\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,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,OAAA,GAAAD,OAAA;AAGA,IAAAE,aAAA,GAAAF,OAAA;AAEA,IAAAG,gBAAA,GAAAH,OAAA;AAEO,IAAMI,YAAY,GAAAC,OAAA,CAAAD,YAAA,GAAG,SAAfA,YAAYA,CACrBE,UAAuB,EACvBC,MAAqC,EACrCC,OAAiD,EAClB;EAC/B,IAAMC,OAAO,GAAG,IAAAC,gCAAe,EAAC,CAAC;EAEjC,IAAMC,IAAI,GAAGL,UAAU,CAACK,IAAI;EAC5B,IAAIC,KAAsD;;EAE1D;EACA,IAAID,IAAI,KAAK,OAAO,EAAE;IAClB;IACAC,KAAK,GAAG,IAAAC,yBAAiB,EACrBJ,OAAO,EACPH,UAAU,EACVC,MAAM,EACNC,OACJ,CAAC;EACL,CAAC,MAAM,IAAIG,IAAI,KAAK,UAAU,EAAE;IAC5B;IACAC,KAAK,GAAG,IAAAE,2BAAoB,EACxBL,OAAO,EACPH,UAAU,EACVC,MAAM;IACN;IACAC,OACJ,CAAC;EACL,CAAC,MAAM;IACH,OAAO,IAAAO,0BAAY,EAACJ,IAAI,sDAAAK,MAAA,CAAsDL,IAAI,CAAE,CAAC;EACzF;EAEA,OAAOC,KAAK;AAChB,CAAC","ignoreList":[]}

package/build/cjs/react-query/hooks/useRefetchInterval.d.ts

@@ -0,0 +1,7 @@
+import type { Query, QueryFunction, SkipToken } from '@tanstack/react-query';
+import type { DataSourceError, DataSourceKey, DataSourceResponse } from '../../core';
+import type { AnyQueryDataSource, RefetchInterval } from '../types';
+export declare const useRefetchInterval: <TDataSource extends AnyQueryDataSource, TQueryData, TPageParams>(refetchIntervalOption?: RefetchInterval<DataSourceResponse<TDataSource>, DataSourceError<TDataSource>, TQueryData, DataSourceKey>, queryFnOption?: QueryFunction<DataSourceResponse<TDataSource>, DataSourceKey, TPageParams> | SkipToken) => {
+    refetchInterval?: number | false | ((query: Query<DataSourceResponse<TDataSource>, DataSourceError<TDataSource>, TQueryData, DataSourceKey>) => number | false | undefined);
+    queryFn?: QueryFunction<DataSourceResponse<TDataSource>, DataSourceKey, TPageParams> | SkipToken;
+};

package/build/cjs/react-query/hooks/useRefetchInterval.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useRefetchInterval = void 0;
+var _react = _interopRequireDefault(require("react"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var useRefetchInterval = exports.useRefetchInterval = function useRefetchInterval(refetchIntervalOption, queryFnOption) {
+  var count = _react.default.useRef(0);
+  var queryFn = _react.default.useMemo(function () {
+    if (typeof queryFnOption === 'function') {
+      return function (context) {
+        count.current++;
+        return queryFnOption(context);
+      };
+    }
+    return undefined;
+  }, [queryFnOption]);
+  var refetchInterval = _react.default.useMemo(function () {
+    if (typeof refetchIntervalOption === 'function') {
+      return function (query) {
+        return refetchIntervalOption(query, count.current);
+      };
+    }
+    return refetchIntervalOption;
+  }, [refetchIntervalOption]);
+  return {
+    refetchInterval: refetchInterval,
+    queryFn: queryFn
+  };
+};
+// #sourceMappingURL=useRefetchInterval.js.map

package/build/cjs/react-query/hooks/useRefetchInterval.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","_interopRequireDefault","require","e","__esModule","default","useRefetchInterval","exports","refetchIntervalOption","queryFnOption","count","React","useRef","queryFn","useMemo","context","current","undefined","refetchInterval","query"],"sources":["useRefetchInterval.ts"],"sourcesContent":["import React from 'react';\n\nimport type {Query, QueryFunction, QueryFunctionContext, SkipToken} from '@tanstack/react-query';\n\nimport type {DataSourceError, DataSourceKey, DataSourceResponse} from '../../core';\nimport type {AnyQueryDataSource, RefetchInterval} from '../types';\n\nexport const useRefetchInterval = <TDataSource extends AnyQueryDataSource, TQueryData, TPageParams>(\n    refetchIntervalOption?: RefetchInterval<\n        DataSourceResponse<TDataSource>,\n        DataSourceError<TDataSource>,\n        TQueryData,\n        DataSourceKey\n    >,\n    queryFnOption?:\n        | QueryFunction<DataSourceResponse<TDataSource>, DataSourceKey, TPageParams>\n        | SkipToken,\n): {\n    refetchInterval?:\n        | number\n        | false\n        | ((\n              query: Query<\n                  DataSourceResponse<TDataSource>,\n                  DataSourceError<TDataSource>,\n                  TQueryData,\n                  DataSourceKey\n              >,\n          ) => number | false | undefined);\n    queryFn?:\n        | QueryFunction<DataSourceResponse<TDataSource>, DataSourceKey, TPageParams>\n        | SkipToken;\n} => {\n    const count = React.useRef<number>(0);\n\n    const queryFn = React.useMemo(() => {\n        if (typeof queryFnOption === 'function') {\n            return (context: QueryFunctionContext<DataSourceKey, TPageParams>) => {\n                count.current++;\n                return queryFnOption(context);\n            };\n        }\n        return undefined;\n    }, [queryFnOption]);\n\n    const refetchInterval = React.useMemo(() => {\n        if (typeof refetchIntervalOption === 'function') {\n            return (\n                query: Query<\n                    DataSourceResponse<TDataSource>,\n                    DataSourceError<TDataSource>,\n                    TQueryData,\n                    DataSourceKey\n                >,\n            ) => {\n                return refetchIntervalOption(query, count.current);\n            };\n        }\n        return refetchIntervalOption;\n    }, [refetchIntervalOption]);\n\n    return {refetchInterval, queryFn};\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AAAyB,SAAAD,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAOlB,IAAMG,kBAAkB,GAAAC,OAAA,CAAAD,kBAAA,GAAG,SAArBA,kBAAkBA,CAC3BE,qBAKC,EACDC,aAEe,EAgBd;EACD,IAAMC,KAAK,GAAGC,cAAK,CAACC,MAAM,CAAS,CAAC,CAAC;EAErC,IAAMC,OAAO,GAAGF,cAAK,CAACG,OAAO,CAAC,YAAM;IAChC,IAAI,OAAOL,aAAa,KAAK,UAAU,EAAE;MACrC,OAAO,UAACM,OAAyD,EAAK;QAClEL,KAAK,CAACM,OAAO,EAAE;QACf,OAAOP,aAAa,CAACM,OAAO,CAAC;MACjC,CAAC;IACL;IACA,OAAOE,SAAS;EACpB,CAAC,EAAE,CAACR,aAAa,CAAC,CAAC;EAEnB,IAAMS,eAAe,GAAGP,cAAK,CAACG,OAAO,CAAC,YAAM;IACxC,IAAI,OAAON,qBAAqB,KAAK,UAAU,EAAE;MAC7C,OAAO,UACHW,KAKC,EACA;QACD,OAAOX,qBAAqB,CAACW,KAAK,EAAET,KAAK,CAACM,OAAO,CAAC;MACtD,CAAC;IACL;IACA,OAAOR,qBAAqB;EAChC,CAAC,EAAE,CAACA,qBAAqB,CAAC,CAAC;EAE3B,OAAO;IAACU,eAAe,EAAfA,eAAe;IAAEL,OAAO,EAAPA;EAAO,CAAC;AACrC,CAAC","ignoreList":[]}

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

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

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

@@ -4,11 +4,42 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useInfiniteQueryData = void 0;
+exports.useInfiniteQueryDataOptions = useInfiniteQueryDataOptions;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _react = require("react");
 var _reactQuery = require("@tanstack/react-query");
+var _useRefetchInterval2 = require("../../hooks/useRefetchInterval");
+var _normalizeStatus = require("../../utils/normalizeStatus");
 var _utils = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _excluded = ["refetchInterval", "queryFn"];
 var useInfiniteQueryData = exports.useInfiniteQueryData = function useInfiniteQueryData(context, dataSource, params, options) {
   var composedOptions = (0, _utils.composeOptions)(context, dataSource, params, options);
-  var result = (0, _reactQuery.useInfiniteQuery)(composedOptions);
-  return (0, _utils.transformResult)(result);
+  var extendedOptions = useInfiniteQueryDataOptions(composedOptions);
+  var result = (0, _reactQuery.useInfiniteQuery)(extendedOptions);
+  var transformedData = (0, _react.useMemo)(function () {
+    var _result$data$pages$fl, _result$data;
+    return (_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 : [];
+  }, [result.data]);
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, result), {}, {
+    status: (0, _normalizeStatus.normalizeStatus)(result.status, result.fetchStatus),
+    data: transformedData,
+    originalStatus: result.status,
+    originalData: result.data
+  });
 };
+function useInfiniteQueryDataOptions(composedOptions) {
+  var _ref = composedOptions || {},
+    refetchIntervalOption = _ref.refetchInterval,
+    queryFnOption = _ref.queryFn,
+    restOptions = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+  var _useRefetchInterval = (0, _useRefetchInterval2.useRefetchInterval)(refetchIntervalOption, queryFnOption),
+    refetchInterval = _useRefetchInterval.refetchInterval,
+    queryFn = _useRefetchInterval.queryFn;
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, restOptions), {}, {
+    refetchInterval: refetchInterval,
+    queryFn: queryFn
+  });
+}
 // #sourceMappingURL=hooks.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["_reactQuery","require","_utils","useInfiniteQueryData","exports","context","dataSource","params","options","composedOptions","composeOptions","result","useInfiniteQuery","transformResult"],"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,IAAAA,WAAA,GAAAC,OAAA;AAUA,IAAAC,MAAA,GAAAD,OAAA;AAEO,IAAME,oBAAoB,GAAAC,OAAA,CAAAD,oBAAA,GAAG,SAAvBA,oBAAoBA,CAC7BE,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAiD,EAClB;EAC/B,IAAMC,eAAe,GAAG,IAAAC,qBAAc,EAACL,OAAO,EAAEC,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EAC5E,IAAMG,MAAM,GAAG,IAAAC,4BAAgB,EAACH,eAAe,CAAC;EAEhD,OAAO,IAAAI,sBAAe,EAACF,MAAM,CAAC;AAClC,CAAC","ignoreList":[]}
+{"version":3,"names":["_react","require","_reactQuery","_useRefetchInterval2","_normalizeStatus","_utils","_interopRequireDefault","e","__esModule","default","useInfiniteQueryData","exports","context","dataSource","params","options","composedOptions","composeOptions","extendedOptions","useInfiniteQueryDataOptions","result","useInfiniteQuery","transformedData","useMemo","_result$data$pages$fl","_result$data","data","pages","flat","_objectSpread","status","normalizeStatus","fetchStatus","originalStatus","originalData","_ref","refetchIntervalOption","refetchInterval","queryFnOption","queryFn","restOptions","_objectWithoutProperties","_excluded","_useRefetchInterval","useRefetchInterval"],"sources":["hooks.ts"],"sourcesContent":["import {useMemo} from 'react';\n\nimport {useInfiniteQuery} from '@tanstack/react-query';\nimport type {InfiniteData, InfiniteQueryObserverOptions} from '@tanstack/react-query';\n\nimport type {\n    DataSourceContext,\n    DataSourceData,\n    DataSourceError,\n    DataSourceKey,\n    DataSourceOptions,\n    DataSourceParams,\n    DataSourceResponse,\n    DataSourceState,\n} from '../../../core';\nimport {useRefetchInterval} from '../../hooks/useRefetchInterval';\nimport {normalizeStatus} from '../../utils/normalizeStatus';\n\nimport type {\n    AnyInfiniteQueryDataSource,\n    AnyPageParam,\n    InfiniteQueryObserverExtendedOptions,\n} from './types';\nimport {composeOptions} 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\n    const extendedOptions = useInfiniteQueryDataOptions(composedOptions);\n\n    const result = useInfiniteQuery(extendedOptions);\n\n    const transformedData = useMemo<DataSourceState<TDataSource>['data']>(\n        () => result.data?.pages.flat(1) ?? [],\n        [result.data],\n    );\n\n    return {\n        ...result,\n        status: normalizeStatus(result.status, result.fetchStatus),\n        data: transformedData,\n        originalStatus: result.status,\n        originalData: result.data,\n    } as DataSourceState<TDataSource>;\n};\n\nexport function useInfiniteQueryDataOptions<TDataSource extends AnyInfiniteQueryDataSource>(\n    composedOptions: InfiniteQueryObserverExtendedOptions<\n        DataSourceResponse<TDataSource>,\n        DataSourceError<TDataSource>,\n        InfiniteData<DataSourceData<TDataSource>, AnyPageParam>,\n        DataSourceResponse<TDataSource>,\n        DataSourceKey,\n        AnyPageParam\n    >,\n): InfiniteQueryObserverOptions<\n    DataSourceResponse<TDataSource>,\n    DataSourceError<TDataSource>,\n    InfiniteData<DataSourceData<TDataSource>, AnyPageParam>,\n    DataSourceResponse<TDataSource>,\n    DataSourceKey,\n    AnyPageParam\n> {\n    const {\n        refetchInterval: refetchIntervalOption,\n        queryFn: queryFnOption,\n        ...restOptions\n    } = composedOptions || {};\n\n    const {refetchInterval, queryFn} = useRefetchInterval(refetchIntervalOption, queryFnOption);\n\n    return {...restOptions, refetchInterval, queryFn};\n}\n"],"mappings":";;;;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,WAAA,GAAAD,OAAA;AAaA,IAAAE,oBAAA,GAAAF,OAAA;AACA,IAAAG,gBAAA,GAAAH,OAAA;AAOA,IAAAI,MAAA,GAAAJ,OAAA;AAAsC,SAAAK,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;;AAE/B,IAAMG,oBAAoB,GAAAC,OAAA,CAAAD,oBAAA,GAAG,SAAvBA,oBAAoBA,CAC7BE,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAiD,EAClB;EAC/B,IAAMC,eAAe,GAAG,IAAAC,qBAAc,EAACL,OAAO,EAAEC,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EAE5E,IAAMG,eAAe,GAAGC,2BAA2B,CAACH,eAAe,CAAC;EAEpE,IAAMI,MAAM,GAAG,IAAAC,4BAAgB,EAACH,eAAe,CAAC;EAEhD,IAAMI,eAAe,GAAG,IAAAC,cAAO,EAC3B;IAAA,IAAAC,qBAAA,EAAAC,YAAA;IAAA,QAAAD,qBAAA,IAAAC,YAAA,GAAML,MAAM,CAACM,IAAI,cAAAD,YAAA,uBAAXA,YAAA,CAAaE,KAAK,CAACC,IAAI,CAAC,CAAC,CAAC,cAAAJ,qBAAA,cAAAA,qBAAA,GAAI,EAAE;EAAA,GACtC,CAACJ,MAAM,CAACM,IAAI,CAChB,CAAC;EAED,WAAAG,sBAAA,MAAAA,sBAAA,MACOT,MAAM;IACTU,MAAM,EAAE,IAAAC,gCAAe,EAACX,MAAM,CAACU,MAAM,EAAEV,MAAM,CAACY,WAAW,CAAC;IAC1DN,IAAI,EAAEJ,eAAe;IACrBW,cAAc,EAAEb,MAAM,CAACU,MAAM;IAC7BI,YAAY,EAAEd,MAAM,CAACM;EAAI;AAEjC,CAAC;AAEM,SAASP,2BAA2BA,CACvCH,eAOC,EAQH;EACE,IAAAmB,IAAA,GAIInB,eAAe,IAAI,CAAC,CAAC;IAHJoB,qBAAqB,GAAAD,IAAA,CAAtCE,eAAe;IACNC,aAAa,GAAAH,IAAA,CAAtBI,OAAO;IACJC,WAAW,OAAAC,iCAAA,EAAAN,IAAA,EAAAO,SAAA;EAGlB,IAAAC,mBAAA,GAAmC,IAAAC,uCAAkB,EAACR,qBAAqB,EAAEE,aAAa,CAAC;IAApFD,eAAe,GAAAM,mBAAA,CAAfN,eAAe;IAAEE,OAAO,GAAAI,mBAAA,CAAPJ,OAAO;EAE/B,WAAAV,sBAAA,MAAAA,sBAAA,MAAWW,WAAW;IAAEH,eAAe,EAAfA,eAAe;IAAEE,OAAO,EAAPA;EAAO;AACpD","ignoreList":[]}

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

@@ -1,8 +1,11 @@
-import type { InfiniteData, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, QueryFunctionContext } from '@tanstack/react-query';
+import type { DefaultError, InfiniteData, InfiniteQueryObserverResult, InfiniteQueryPageParamsOptions, QueryFunctionContext, QueryKey } 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, 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>>> & {
+import type { QueryObserverExtendedOptions } from '../plain/types';
+export interface InfiniteQueryObserverExtendedOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends QueryObserverExtendedOptions<TQueryFnData, TError, TData, InfiniteData<TQueryData, TPageParam>, TQueryKey, TPageParam>, InfiniteQueryPageParamsOptions<TQueryFnData, TPageParam> {
+}
+export type InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError> = DataSource<QueryDataSourceContext, TParams, TRequest, TResponse, TData, TError, InfiniteQueryObserverExtendedOptions<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> | null | undefined;
     prev?: (firstPage: TResponse, allPages: TResponse[]) => Partial<TRequest> | null | undefined;

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

@@ -1 +1 @@
-{"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<TParams, TRequest, TResponse, TData, TError> = 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              {\n                  status: DataLoaderStatus;\n                  data: Array<FlatArray<Array<ActualData<TData, TResponse>>, 1>>;\n              }\n          > & {\n              originalStatus: TResult['status'];\n              originalData: TResult['data'];\n          }\n        : never;\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type {\n    DefaultError,\n    InfiniteData,\n    InfiniteQueryObserverResult,\n    InfiniteQueryPageParamsOptions,\n    QueryFunctionContext,\n    QueryKey,\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';\nimport type {QueryObserverExtendedOptions} from '../plain/types';\n\nexport interface InfiniteQueryObserverExtendedOptions<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n> extends QueryObserverExtendedOptions<\n            TQueryFnData,\n            TError,\n            TData,\n            InfiniteData<TQueryData, TPageParam>,\n            TQueryKey,\n            TPageParam\n        >,\n        InfiniteQueryPageParamsOptions<TQueryFnData, TPageParam> {}\n\nexport type InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError> = DataSource<\n    QueryDataSourceContext,\n    TParams,\n    TRequest,\n    TResponse,\n    TData,\n    TError,\n    InfiniteQueryObserverExtendedOptions<\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              {\n                  status: DataLoaderStatus;\n                  data: Array<FlatArray<Array<ActualData<TData, TResponse>>, 1>>;\n              }\n          > & {\n              originalStatus: TResult['status'];\n              originalData: TResult['data'];\n          }\n        : never;\n"],"mappings":"","ignoreList":[]}

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

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

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

@@ -3,13 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.transformResult = exports.composeOptions = void 0;
+exports.composeOptions = void 0;
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 var _reactQuery = require("@tanstack/react-query");
 var _core = require("../../../core");
-var _normalizeStatus = require("../../utils/normalizeStatus");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-var EMPTY_ARRAY = [];
 var EMPTY_OBJECT = {};
 var composeOptions = exports.composeOptions = function composeOptions(context, dataSource, params, options) {
   var transformParams = dataSource.transformParams,
@@ -34,13 +32,4 @@ var composeOptions = exports.composeOptions = function composeOptions(context, d
     getPreviousPageParam: prev
   }, dataSource.options), options);
 };
-var transformResult = exports.transformResult = function transformResult(result) {
-  var _result$data$pages$fl, _result$data;
-  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, result), {}, {
-    status: (0, _normalizeStatus.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(1)) !== null && _result$data$pages$fl !== void 0 ? _result$data$pages$fl : EMPTY_ARRAY,
-    originalStatus: result.status,
-    originalData: result.data
-  });
-};
 // #sourceMappingURL=utils.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["_reactQuery","require","_core","_normalizeStatus","_interopRequireDefault","e","__esModule","default","EMPTY_ARRAY","EMPTY_OBJECT","composeOptions","exports","context","dataSource","params","options","transformParams","transformResponse","next","prev","queryFn","fetchContext","request","paginatedRequest","_objectSpread","pageParam","fetch","queryKey","composeFullKey","idle","skipToken","select","data","pages","map","undefined","initialPageParam","getNextPageParam","getPreviousPageParam","transformResult","result","_result$data$pages$fl","_result$data","status","normalizeStatus","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,IAAAA,WAAA,GAAAC,OAAA;AAQA,IAAAC,KAAA,GAAAD,OAAA;AAWA,IAAAE,gBAAA,GAAAF,OAAA;AAA2D,SAAAG,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAI3D,IAAMG,WAAsB,GAAG,EAAE;AACjC,IAAMC,YAAY,GAAG,CAAC,CAAC;AAEhB,IAAMC,cAAc,GAAAC,OAAA,CAAAD,cAAA,GAAG,SAAjBA,cAAcA,CACvBE,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,OAAAC,sBAAA,MAAAA,sBAAA,MAAOF,OAAO,GAAKD,YAAY,CAACI,SAAS,CAAC;IAEhE,OAAOZ,UAAU,CAACa,KAAK,CAACd,OAAO,EAAES,YAAY,EAAEE,gBAAgB,CAAC;EACpE,CAAC;EAED,WAAAC,sBAAA,MAAAA,sBAAA;IACIG,QAAQ,EAAE,IAAAC,oBAAc,EAACf,UAAU,EAAEC,MAAM,CAAC;IAC5CM,OAAO,EAAEN,MAAM,KAAKe,UAAI,GAAGC,qBAAS,GAAGV,OAAO;IAC9CW,MAAM,EAAEd,iBAAiB,GACnB,UAACe,IAAI;MAAA,WAAAR,sBAAA,MAAAA,sBAAA,MAAUQ,IAAI;QAAEC,KAAK,EAAED,IAAI,CAACC,KAAK,CAACC,GAAG,CAACjB,iBAAiB;MAAC;IAAA,CAAE,GAC/DkB,SAAS;IACfC,gBAAgB,EAAE3B,YAAY;IAC9B4B,gBAAgB,EAAEnB,IAAI;IACtBoB,oBAAoB,EAAEnB;EAAI,GACvBN,UAAU,CAACE,OAAO,GAClBA,OAAO;AAElB,CAAC;AAEM,IAAMwB,eAAe,GAAA5B,OAAA,CAAA4B,eAAA,GAAG,SAAlBA,eAAeA,CACxBC,MAGC,EAC8B;EAAA,IAAAC,qBAAA,EAAAC,YAAA;EAC/B,WAAAlB,sBAAA,MAAAA,sBAAA,MACOgB,MAAM;IACTG,MAAM,EAAE,IAAAC,gCAAe,EAACJ,MAAM,CAACG,MAAM,EAAEH,MAAM,CAACK,WAAW,CAAC;IAC1Db,IAAI,GAAAS,qBAAA,IAAAC,YAAA,GAAEF,MAAM,CAACR,IAAI,cAAAU,YAAA,uBAAXA,YAAA,CAAaT,KAAK,CAACa,IAAI,CAAC,CAAC,CAAC,cAAAL,qBAAA,cAAAA,qBAAA,GAAIjC,WAAW;IAC/CuC,cAAc,EAAEP,MAAM,CAACG,MAAM;IAC7BK,YAAY,EAAER,MAAM,CAACR;EAAI;AAEjC,CAAC","ignoreList":[]}
+{"version":3,"names":["_reactQuery","require","_core","_interopRequireDefault","e","__esModule","default","EMPTY_OBJECT","composeOptions","exports","context","dataSource","params","options","transformParams","transformResponse","next","prev","queryFn","fetchContext","request","paginatedRequest","_objectSpread","pageParam","fetch","queryKey","composeFullKey","idle","skipToken","select","data","pages","map","undefined","initialPageParam","getNextPageParam","getPreviousPageParam"],"sources":["utils.ts"],"sourcesContent":["import {skipToken} from '@tanstack/react-query';\nimport type {InfiniteData, QueryFunctionContext} 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} from '../../../core';\n\nimport type {\n    AnyInfiniteQueryDataSource,\n    AnyPageParam,\n    InfiniteQueryObserverExtendedOptions,\n} from './types';\n\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): InfiniteQueryObserverExtendedOptions<\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"],"mappings":";;;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAGA,IAAAC,KAAA,GAAAD,OAAA;AAAkD,SAAAE,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAiBlD,IAAMG,YAAY,GAAG,CAAC,CAAC;AAEhB,IAAMC,cAAc,GAAAC,OAAA,CAAAD,cAAA,GAAG,SAAjBA,cAAcA,CACvBE,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,OAAAC,sBAAA,MAAAA,sBAAA,MAAOF,OAAO,GAAKD,YAAY,CAACI,SAAS,CAAC;IAEhE,OAAOZ,UAAU,CAACa,KAAK,CAACd,OAAO,EAAES,YAAY,EAAEE,gBAAgB,CAAC;EACpE,CAAC;EAED,WAAAC,sBAAA,MAAAA,sBAAA;IACIG,QAAQ,EAAE,IAAAC,oBAAc,EAACf,UAAU,EAAEC,MAAM,CAAC;IAC5CM,OAAO,EAAEN,MAAM,KAAKe,UAAI,GAAGC,qBAAS,GAAGV,OAAO;IAC9CW,MAAM,EAAEd,iBAAiB,GACnB,UAACe,IAAI;MAAA,WAAAR,sBAAA,MAAAA,sBAAA,MAAUQ,IAAI;QAAEC,KAAK,EAAED,IAAI,CAACC,KAAK,CAACC,GAAG,CAACjB,iBAAiB;MAAC;IAAA,CAAE,GAC/DkB,SAAS;IACfC,gBAAgB,EAAE3B,YAAY;IAC9B4B,gBAAgB,EAAEnB,IAAI;IACtBoB,oBAAoB,EAAEnB;EAAI,GACvBN,UAAU,CAACE,OAAO,GAClBA,OAAO;AAElB,CAAC","ignoreList":[]}

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

@@ -1,3 +1,6 @@
-import type { DataSourceContext, DataSourceOptions, DataSourceParams, DataSourceState } from '../../../core';
-import type { AnyPlainQueryDataSource } from './types';
+import { type QueryObserverOptions } from '@tanstack/react-query';
+import type { DataSourceContext, DataSourceData, DataSourceError, DataSourceKey, DataSourceOptions, DataSourceParams, DataSourceResponse, DataSourceState } from '../../../core';
+import type { AnyQueryDataSource } from '../../types';
+import type { AnyPlainQueryDataSource, QueryObserverExtendedOptions } from './types';
 export declare const usePlainQueryData: <TDataSource extends AnyPlainQueryDataSource>(context: DataSourceContext<TDataSource>, dataSource: TDataSource, params: DataSourceParams<TDataSource>, options?: Partial<DataSourceOptions<TDataSource>>) => DataSourceState<TDataSource>;
+export declare function useQueryDataOptions<TDataSource extends AnyQueryDataSource>(composedOptions: QueryObserverExtendedOptions<DataSourceResponse<TDataSource>, DataSourceError<TDataSource>, DataSourceData<TDataSource>, DataSourceResponse<TDataSource>, DataSourceKey>): QueryObserverOptions<DataSourceResponse<TDataSource>, DataSourceError<TDataSource>, DataSourceData<TDataSource>, DataSourceResponse<TDataSource>, DataSourceKey>;

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

@@ -4,11 +4,35 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.usePlainQueryData = void 0;
+exports.useQueryDataOptions = useQueryDataOptions;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 var _reactQuery = require("@tanstack/react-query");
+var _useRefetchInterval2 = require("../../hooks/useRefetchInterval");
+var _normalizeStatus = require("../../utils/normalizeStatus");
 var _utils = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _excluded = ["refetchInterval", "queryFn"];
 var usePlainQueryData = exports.usePlainQueryData = function usePlainQueryData(context, dataSource, params, options) {
   var composedOptions = (0, _utils.composeOptions)(context, dataSource, params, options);
-  var result = (0, _reactQuery.useQuery)(composedOptions);
-  return (0, _utils.transformResult)(result);
+  var extendedOptions = useQueryDataOptions(composedOptions);
+  var result = (0, _reactQuery.useQuery)(extendedOptions);
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, result), {}, {
+    status: (0, _normalizeStatus.normalizeStatus)(result.status, result.fetchStatus),
+    originalStatus: result.status
+  });
 };
+function useQueryDataOptions(composedOptions) {
+  var _ref = composedOptions || {},
+    refetchIntervalOption = _ref.refetchInterval,
+    queryFnOption = _ref.queryFn,
+    restOptions = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+  var _useRefetchInterval = (0, _useRefetchInterval2.useRefetchInterval)(refetchIntervalOption, queryFnOption),
+    refetchInterval = _useRefetchInterval.refetchInterval,
+    queryFn = _useRefetchInterval.queryFn;
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, restOptions), {}, {
+    refetchInterval: refetchInterval,
+    queryFn: queryFn
+  });
+}
 // #sourceMappingURL=hooks.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["_reactQuery","require","_utils","usePlainQueryData","exports","context","dataSource","params","options","composedOptions","composeOptions","result","useQuery","transformResult"],"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,IAAAA,WAAA,GAAAC,OAAA;AAUA,IAAAC,MAAA,GAAAD,OAAA;AAEO,IAAME,iBAAiB,GAAAC,OAAA,CAAAD,iBAAA,GAAG,SAApBA,iBAAiBA,CAC1BE,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAiD,EAClB;EAC/B,IAAMC,eAAe,GAAG,IAAAC,qBAAc,EAACL,OAAO,EAAEC,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EAC5E,IAAMG,MAAM,GAAG,IAAAC,oBAAQ,EAACH,eAAe,CAAC;EAExC,OAAO,IAAAI,sBAAe,EAACF,MAAM,CAAC;AAClC,CAAC","ignoreList":[]}
+{"version":3,"names":["_reactQuery","require","_useRefetchInterval2","_normalizeStatus","_utils","_interopRequireDefault","e","__esModule","default","usePlainQueryData","exports","context","dataSource","params","options","composedOptions","composeOptions","extendedOptions","useQueryDataOptions","result","useQuery","_objectSpread","status","normalizeStatus","fetchStatus","originalStatus","_ref","refetchIntervalOption","refetchInterval","queryFnOption","queryFn","restOptions","_objectWithoutProperties","_excluded","_useRefetchInterval","useRefetchInterval"],"sources":["hooks.ts"],"sourcesContent":["import {type QueryObserverOptions, useQuery} from '@tanstack/react-query';\n\nimport type {\n    DataSourceContext,\n    DataSourceData,\n    DataSourceError,\n    DataSourceKey,\n    DataSourceOptions,\n    DataSourceParams,\n    DataSourceResponse,\n    DataSourceState,\n} from '../../../core';\nimport {useRefetchInterval} from '../../hooks/useRefetchInterval';\nimport type {AnyQueryDataSource} from '../../types';\nimport {normalizeStatus} from '../../utils/normalizeStatus';\n\nimport type {AnyPlainQueryDataSource, QueryObserverExtendedOptions} from './types';\nimport {composeOptions} 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\n    const extendedOptions = useQueryDataOptions(composedOptions);\n\n    const result = useQuery(extendedOptions);\n\n    return {\n        ...result,\n        status: normalizeStatus(result.status, result.fetchStatus),\n        originalStatus: result.status,\n    } as DataSourceState<TDataSource>;\n};\n\nexport function useQueryDataOptions<TDataSource extends AnyQueryDataSource>(\n    composedOptions: QueryObserverExtendedOptions<\n        DataSourceResponse<TDataSource>,\n        DataSourceError<TDataSource>,\n        DataSourceData<TDataSource>,\n        DataSourceResponse<TDataSource>,\n        DataSourceKey\n    >,\n): QueryObserverOptions<\n    DataSourceResponse<TDataSource>,\n    DataSourceError<TDataSource>,\n    DataSourceData<TDataSource>,\n    DataSourceResponse<TDataSource>,\n    DataSourceKey\n> {\n    const {\n        refetchInterval: refetchIntervalOption,\n        queryFn: queryFnOption,\n        ...restOptions\n    } = composedOptions || {};\n\n    const {refetchInterval, queryFn} = useRefetchInterval(refetchIntervalOption, queryFnOption);\n\n    return {...restOptions, refetchInterval, queryFn};\n}\n"],"mappings":";;;;;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAYA,IAAAC,oBAAA,GAAAD,OAAA;AAEA,IAAAE,gBAAA,GAAAF,OAAA;AAGA,IAAAG,MAAA,GAAAH,OAAA;AAAsC,SAAAI,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;;AAE/B,IAAMG,iBAAiB,GAAAC,OAAA,CAAAD,iBAAA,GAAG,SAApBA,iBAAiBA,CAC1BE,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAiD,EAClB;EAC/B,IAAMC,eAAe,GAAG,IAAAC,qBAAc,EAACL,OAAO,EAAEC,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EAE5E,IAAMG,eAAe,GAAGC,mBAAmB,CAACH,eAAe,CAAC;EAE5D,IAAMI,MAAM,GAAG,IAAAC,oBAAQ,EAACH,eAAe,CAAC;EAExC,WAAAI,sBAAA,MAAAA,sBAAA,MACOF,MAAM;IACTG,MAAM,EAAE,IAAAC,gCAAe,EAACJ,MAAM,CAACG,MAAM,EAAEH,MAAM,CAACK,WAAW,CAAC;IAC1DC,cAAc,EAAEN,MAAM,CAACG;EAAM;AAErC,CAAC;AAEM,SAASJ,mBAAmBA,CAC/BH,eAMC,EAOH;EACE,IAAAW,IAAA,GAIIX,eAAe,IAAI,CAAC,CAAC;IAHJY,qBAAqB,GAAAD,IAAA,CAAtCE,eAAe;IACNC,aAAa,GAAAH,IAAA,CAAtBI,OAAO;IACJC,WAAW,OAAAC,iCAAA,EAAAN,IAAA,EAAAO,SAAA;EAGlB,IAAAC,mBAAA,GAAmC,IAAAC,uCAAkB,EAACR,qBAAqB,EAAEE,aAAa,CAAC;IAApFD,eAAe,GAAAM,mBAAA,CAAfN,eAAe;IAAEE,OAAO,GAAAI,mBAAA,CAAPJ,OAAO;EAE/B,WAAAT,sBAAA,MAAAA,sBAAA,MAAWU,WAAW;IAAEH,eAAe,EAAfA,eAAe;IAAEE,OAAO,EAAPA;EAAO;AACpD","ignoreList":[]}

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

@@ -1,8 +1,9 @@
-import type { QueryFunctionContext, QueryObserverOptions, QueryObserverResult } from '@tanstack/react-query';
+import type { DefaultError, QueryFunctionContext, QueryKey, QueryObserverOptions, QueryObserverResult } 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 PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError> = DataSource<QueryDataSourceContext, TParams, TRequest, TResponse, TData, TError, QueryObserverOptions<TResponse, TError, ActualData<TData, TResponse>, TResponse, DataSourceKey>, ResultWrapper<QueryObserverResult<ActualData<TData, TResponse>, TError>, TResponse, TData, TError>, QueryFunctionContext<DataSourceKey>> & {
+import type { QueryDataExtendedOptions, QueryDataSourceContext } from '../../types';
+export type QueryObserverExtendedOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'refetchInterval'> & QueryDataExtendedOptions<TQueryFnData, TError, TQueryData, TQueryKey>;
+export type PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError> = DataSource<QueryDataSourceContext, TParams, TRequest, TResponse, TData, TError, QueryObserverExtendedOptions<TResponse, TError, ActualData<TData, TResponse>, TResponse, DataSourceKey>, ResultWrapper<QueryObserverResult<ActualData<TData, TResponse>, TError>, TResponse, TData, TError>, QueryFunctionContext<DataSourceKey>> & {
     type: 'plain';
 };
 export type AnyPlainQueryDataSource = PlainQueryDataSource<any, any, any, any, any>;

package/build/cjs/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, DataSourceKey>,\n    ResultWrapper<\n        QueryObserverResult<ActualData<TData, TResponse>, TError>,\n        TResponse,\n        TData,\n        TError\n    >,\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, TResponse, TData, TError> =\n    TResult extends QueryObserverResult<ActualData<TData, TResponse>, TError>\n        ? Overwrite<TResult, {status: DataLoaderStatus}> & {originalStatus: TResult['status']}\n        : never;\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type {\n    DefaultError,\n    QueryFunctionContext,\n    QueryKey,\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 {QueryDataExtendedOptions, QueryDataSourceContext} from '../../types';\n\nexport type QueryObserverExtendedOptions<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = never,\n> = Omit<\n    QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>,\n    'refetchInterval'\n> &\n    QueryDataExtendedOptions<TQueryFnData, TError, TQueryData, TQueryKey>;\n\nexport type PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError> = DataSource<\n    QueryDataSourceContext,\n    TParams,\n    TRequest,\n    TResponse,\n    TData,\n    TError,\n    QueryObserverExtendedOptions<\n        TResponse,\n        TError,\n        ActualData<TData, TResponse>,\n        TResponse,\n        DataSourceKey\n    >,\n    ResultWrapper<\n        QueryObserverResult<ActualData<TData, TResponse>, TError>,\n        TResponse,\n        TData,\n        TError\n    >,\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, TResponse, TData, TError> =\n    TResult extends QueryObserverResult<ActualData<TData, TResponse>, TError>\n        ? Overwrite<TResult, {status: DataLoaderStatus}> & {originalStatus: TResult['status']}\n        : never;\n"],"mappings":"","ignoreList":[]}