npm - @gravity-ui/data-source - Versions diffs - 0.3.0 → 0.5.0 - Mend

@gravity-ui/data-source 0.3.0 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (94) hide show

package/build/cjs/react-query/impl/plain/utils.d.ts CHANGED Viewed

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

package/build/cjs/react-query/impl/plain/utils.js CHANGED Viewed

@@ -3,11 +3,10 @@
 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 composeOptions = exports.composeOptions = function composeOptions(context, dataSource, params, options) {
   var transformParams = dataSource.transformParams;
@@ -20,10 +19,4 @@ var composeOptions = exports.composeOptions = function composeOptions(context, d
     select: dataSource.transformResponse
   }, dataSource.options), options);
 };
-var transformResult = exports.transformResult = function transformResult(result) {
-  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, result), {}, {
-    status: (0, _normalizeStatus.normalizeStatus)(result.status, result.fetchStatus),
-    originalStatus: result.status
-  });
-};
 // #sourceMappingURL=utils.js.map

package/build/cjs/react-query/impl/plain/utils.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"names":["_reactQuery","require","_core","~~_normalizeStatus","~~_interopRequireDefault","e","__esModule","default","composeOptions","exports","context","dataSource","params","options","transformParams","queryFn","fetchContext","fetch","_objectSpread","queryKey","composeFullKey","idle","skipToken","select","transformResponse"~~,"transformResult","result","status","normalizeStatus","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,IAAAA,WAAA,GAAAC,OAAA;~~AAOA~~,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;~~AAIpD~~,IAAMG,cAAc,GAAAC,OAAA,CAAAD,cAAA,GAAG,SAAjBA,cAAcA,CACvBE,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,WAAAM,sBAAA,MAAAA,sBAAA;IACIC,QAAQ,EAAE,IAAAC,oBAAc,EAACT,UAAU,EAAEC,MAAM,CAAC;IAC5CG,OAAO,EAAEH,MAAM,KAAKS,UAAI,GAAGC,qBAAS,GAAGP,OAAO;IAC9CQ,MAAM,EAAEZ,UAAU,CAACa;EAAiB,GACjCb,UAAU,CAACE,OAAO,GAClBA,OAAO;AAElB,CAAC;AAEM,IAAMY,eAAe,GAAAhB,OAAA,CAAAgB,eAAA,GAAG,SAAlBA,eAAeA,CACxBC,MAAsF,EACvD;EAC/B,WAAAR,sBAAA,MAAAA,sBAAA,MACOQ,MAAM;IACTC,MAAM,EAAE,IAAAC,gCAAe,EAACF,MAAM,CAACC,MAAM,EAAED,MAAM,CAACG,WAAW,CAAC;IAC1DC,cAAc,EAAEJ,MAAM,CAACC;EAAM;AAErC,CAAC","ignoreList":[]}
1	+ {"version":3,"names":["_reactQuery","require","_core","_interopRequireDefault","e","__esModule","default","composeOptions","exports","context","dataSource","params","options","transformParams","queryFn","fetchContext","fetch","_objectSpread","queryKey","composeFullKey","idle","skipToken","select","transformResponse"],"sources":["utils.ts"],"sourcesContent":["import {type QueryFunctionContext, skipToken} 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 {AnyPlainQueryDataSource, QueryObserverExtendedOptions} 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): QueryObserverExtendedOptions<\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"],"mappings":";;;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAEA,IAAAC,KAAA,GAAAD,OAAA;AAAkD,SAAAE,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAa3C,IAAMG,cAAc,GAAAC,OAAA,CAAAD,cAAA,GAAG,SAAjBA,cAAcA,CACvBE,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,WAAAM,sBAAA,MAAAA,sBAAA;IACIC,QAAQ,EAAE,IAAAC,oBAAc,EAACT,UAAU,EAAEC,MAAM,CAAC;IAC5CG,OAAO,EAAEH,MAAM,KAAKS,UAAI,GAAGC,qBAAS,GAAGP,OAAO;IAC9CQ,MAAM,EAAEZ,UAAU,CAACa;EAAiB,GACjCb,UAAU,CAACE,OAAO,GAClBA,OAAO;AAElB,CAAC","ignoreList":[]}

package/build/cjs/react-query/index.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-export type { QueryDataSourceContext, AnyQueryDataSource } from './types';
+export type { QueryDataSourceContext, AnyQueryDataSource, ProgressiveRefetchInterval, RefetchInterval, RefetchIntervalFunction, } from './types';
 export { useQueryContext } from './hooks/useQueryContext';
 export { useQueryData } from './hooks/useQueryData';
 export { useQueryResponses } from './hooks/useQueryResponses';
@@ -11,5 +11,6 @@ export type { PlainQueryDataSource, AnyPlainQueryDataSource } from './impl/plain
 export { makePlainQueryDataSource } from './impl/plain/factory';
 export { composeOptions as composePlainQueryOptions } from './impl/plain/utils';
 export { normalizeStatus } from './utils/normalizeStatus';
+export { getProgressiveRefetch } from './utils/getProgressiveRefetch';
 export type { ClientDataManagerConfig } from './ClientDataManager';
 export { ClientDataManager } from './ClientDataManager';

package/build/cjs/react-query/index.js CHANGED Viewed

@@ -21,6 +21,12 @@ Object.defineProperty(exports, "composePlainQueryOptions", {
     return _utils2.composeOptions;
   }
 });
+Object.defineProperty(exports, "getProgressiveRefetch", {
+  enumerable: true,
+  get: function () {
+    return _getProgressiveRefetch.getProgressiveRefetch;
+  }
+});
 Object.defineProperty(exports, "makeInfiniteQueryDataSource", {
   enumerable: true,
   get: function () {
@@ -79,5 +85,6 @@ var _utils = require("./impl/infinite/utils");
 var _factory2 = require("./impl/plain/factory");
 var _utils2 = require("./impl/plain/utils");
 var _normalizeStatus = require("./utils/normalizeStatus");
+var _getProgressiveRefetch = require("./utils/getProgressiveRefetch");
 var _ClientDataManager = require("./ClientDataManager");
 // #sourceMappingURL=index.js.map

package/build/cjs/react-query/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"names":["_useQueryContext","require","_useQueryData","_useQueryResponses","_useRefetchAll","_useRefetchErrored","_factory","_utils","_factory2","_utils2","_normalizeStatus","_ClientDataManager"],"sources":["index.ts"],"sourcesContent":["export type {QueryDataSourceContext, AnyQueryDataSource} from './types';\n\nexport {useQueryContext} from './hooks/useQueryContext';\nexport {useQueryData} from './hooks/useQueryData';\nexport {useQueryResponses} from './hooks/useQueryResponses';\nexport {useRefetchAll} from './hooks/useRefetchAll';\nexport {useRefetchErrored} from './hooks/useRefetchErrored';\n\nexport type {InfiniteQueryDataSource, AnyInfiniteQueryDataSource} from './impl/infinite/types';\nexport {makeInfiniteQueryDataSource} from './impl/infinite/factory';\nexport {composeOptions as composeInfiniteQueryOptions} from './impl/infinite/utils';\n\nexport type {PlainQueryDataSource, AnyPlainQueryDataSource} from './impl/plain/types';\nexport {makePlainQueryDataSource} from './impl/plain/factory';\nexport {composeOptions as composePlainQueryOptions} from './impl/plain/utils';\n\nexport {normalizeStatus} from './utils/normalizeStatus';\n\nexport type {ClientDataManagerConfig} from './ClientDataManager';\nexport {ClientDataManager} from './ClientDataManager';\n"],"mappings":"~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA~~,IAAAA,gBAAA,GAAAC,OAAA;AACA,IAAAC,aAAA,GAAAD,OAAA;AACA,IAAAE,kBAAA,GAAAF,OAAA;AACA,IAAAG,cAAA,GAAAH,OAAA;AACA,IAAAI,kBAAA,GAAAJ,OAAA;AAGA,IAAAK,QAAA,GAAAL,OAAA;AACA,IAAAM,MAAA,GAAAN,OAAA;AAGA,IAAAO,SAAA,GAAAP,OAAA;AACA,IAAAQ,OAAA,GAAAR,OAAA;AAEA,IAAAS,gBAAA,GAAAT,OAAA;~~AAGA~~,IAAAU,~~kBAAA~~,GAAAV,OAAA","ignoreList":[]}
1	+ {"version":3,"names":["_useQueryContext","require","_useQueryData","_useQueryResponses","_useRefetchAll","_useRefetchErrored","_factory","_utils","_factory2","_utils2","_normalizeStatus","_getProgressiveRefetch","_ClientDataManager"],"sources":["index.ts"],"sourcesContent":["export type {\n QueryDataSourceContext,\n AnyQueryDataSource,\n ProgressiveRefetchInterval,\n RefetchInterval,\n RefetchIntervalFunction,\n} from './types';\n\nexport {useQueryContext} from './hooks/useQueryContext';\nexport {useQueryData} from './hooks/useQueryData';\nexport {useQueryResponses} from './hooks/useQueryResponses';\nexport {useRefetchAll} from './hooks/useRefetchAll';\nexport {useRefetchErrored} from './hooks/useRefetchErrored';\n\nexport type {InfiniteQueryDataSource, AnyInfiniteQueryDataSource} from './impl/infinite/types';\nexport {makeInfiniteQueryDataSource} from './impl/infinite/factory';\nexport {composeOptions as composeInfiniteQueryOptions} from './impl/infinite/utils';\n\nexport type {PlainQueryDataSource, AnyPlainQueryDataSource} from './impl/plain/types';\nexport {makePlainQueryDataSource} from './impl/plain/factory';\nexport {composeOptions as composePlainQueryOptions} from './impl/plain/utils';\n\nexport {normalizeStatus} from './utils/normalizeStatus';\nexport {getProgressiveRefetch} from './utils/getProgressiveRefetch';\n\nexport type {ClientDataManagerConfig} from './ClientDataManager';\nexport {ClientDataManager} from './ClientDataManager';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,IAAAA,gBAAA,GAAAC,OAAA;AACA,IAAAC,aAAA,GAAAD,OAAA;AACA,IAAAE,kBAAA,GAAAF,OAAA;AACA,IAAAG,cAAA,GAAAH,OAAA;AACA,IAAAI,kBAAA,GAAAJ,OAAA;AAGA,IAAAK,QAAA,GAAAL,OAAA;AACA,IAAAM,MAAA,GAAAN,OAAA;AAGA,IAAAO,SAAA,GAAAP,OAAA;AACA,IAAAQ,OAAA,GAAAR,OAAA;AAEA,IAAAS,gBAAA,GAAAT,OAAA;AACA,IAAAU,sBAAA,GAAAV,OAAA;AAGA,IAAAW,kBAAA,GAAAX,OAAA","ignoreList":[]}

package/build/cjs/react-query/{types.d.ts → types/base.d.ts} RENAMED Viewed

@@ -1,6 +1,6 @@
 import type { QueryClient } from '@tanstack/react-query';
-import type { AnyInfiniteQueryDataSource } from './impl/infinite/types';
-import type { AnyPlainQueryDataSource } from './impl/plain/types';
+import type { AnyInfiniteQueryDataSource } from '../impl/infinite/types';
+import type { AnyPlainQueryDataSource } from '../impl/plain/types';
 export interface QueryDataSourceContext {
     queryClient: QueryClient;
 }

package/build/cjs/react-query/{types.js → types/base.js} RENAMED Viewed

@@ -3,4 +3,4 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-// #sourceMappingURL=types.js.map
+// #sourceMappingURL=base.js.map

package/build/cjs/react-query/types/base.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"names":[],"sources":["base.ts"],"sourcesContent":["import type {QueryClient} from '@tanstack/react-query';\n\nimport type {AnyInfiniteQueryDataSource} from '../impl/infinite/types';\nimport type {AnyPlainQueryDataSource} from '../impl/plain/types';\n\nexport interface QueryDataSourceContext {\n queryClient: QueryClient;\n}\n\nexport type AnyQueryDataSource = AnyPlainQueryDataSource | AnyInfiniteQueryDataSource;\n"],"mappings":"","ignoreList":[]}

package/build/cjs/react-query/types/index.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export * from './base';
2	+ export * from './refetch-interval';

package/build/cjs/react-query/types/index.js ADDED Viewed

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _base = require("./base");
+Object.keys(_base).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _base[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _base[key];
+    }
+  });
+});
+var _refetchInterval = require("./refetch-interval");
+Object.keys(_refetchInterval).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _refetchInterval[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _refetchInterval[key];
+    }
+  });
+});
+// #sourceMappingURL=index.js.map

package/build/cjs/react-query/types/index.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"names":["_base","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_refetchInterval"],"sources":["index.ts"],"sourcesContent":["export * from './base';\nexport * from './refetch-interval';\n"],"mappings":";;;;;AAAA,IAAAA,KAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,KAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,KAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,KAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,gBAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,gBAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,gBAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,gBAAA,CAAAL,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

package/build/cjs/react-query/types/refetch-interval.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import type { DefaultError, Query, QueryKey } from '@tanstack/react-query';
+export type RefetchIntervalFunction<TQueryFnData = unknown, TError = DefaultError, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = (query: Query<TQueryFnData, TError, TQueryData, TQueryKey>, count: number) => number | false | undefined;
+export type RefetchInterval<TQueryFnData = unknown, TError = DefaultError, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = number | false | RefetchIntervalFunction<TQueryFnData, TError, TQueryData, TQueryKey>;
+export interface ProgressiveRefetchInterval {
+    minInterval: number;
+    maxInterval: number;
+}
+export interface QueryDataExtendedOptions<TQueryFnData = unknown, TError = DefaultError, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> {
+    refetchInterval?: RefetchInterval<TQueryFnData, TError, TQueryData, TQueryKey>;
+}

package/build/cjs/react-query/types/refetch-interval.js ADDED Viewed

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

package/build/cjs/react-query/types/refetch-interval.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"names":[],"sources":["refetch-interval.ts"],"sourcesContent":["import type {DefaultError, Query, QueryKey} from '@tanstack/react-query';\n\nexport type RefetchIntervalFunction<\n TQueryFnData = unknown,\n TError = DefaultError,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = (\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey>,\n count: number,\n) => number | false | undefined;\n\nexport type RefetchInterval<\n TQueryFnData = unknown,\n TError = DefaultError,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = number | false | RefetchIntervalFunction<TQueryFnData, TError, TQueryData, TQueryKey>;\n\nexport interface ProgressiveRefetchInterval {\n minInterval: number;\n maxInterval: number;\n}\n\nexport interface QueryDataExtendedOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> {\n refetchInterval?: RefetchInterval<TQueryFnData, TError, TQueryData, TQueryKey>;\n}\n"],"mappings":"","ignoreList":[]}

package/build/cjs/react-query/utils/getProgressiveRefetch.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import type { QueryKey } from '@tanstack/react-query';
+import type { ProgressiveRefetchInterval, RefetchIntervalFunction } from '../types';
+export declare const getProgressiveRefetch: <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>({ minInterval, maxInterval, }: ProgressiveRefetchInterval) => RefetchIntervalFunction<TQueryFnData, TError, TData, TQueryKey>;

package/build/cjs/react-query/utils/getProgressiveRefetch.js ADDED Viewed

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getProgressiveRefetch = void 0;
+var BASE = 2;
+var getProgressiveRefetch = exports.getProgressiveRefetch = function getProgressiveRefetch(_ref) {
+  var minInterval = _ref.minInterval,
+    maxInterval = _ref.maxInterval;
+  return function (_, queryRefetchCount) {
+    return Math.min(minInterval * Math.pow(BASE, queryRefetchCount), maxInterval);
+  };
+};
+// #sourceMappingURL=getProgressiveRefetch.js.map

package/build/cjs/react-query/utils/getProgressiveRefetch.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"names":["BASE","getProgressiveRefetch","exports","_ref","minInterval","maxInterval","_","queryRefetchCount","Math","min","pow"],"sources":["getProgressiveRefetch.ts"],"sourcesContent":["import type {DefaultError, QueryKey} from '@tanstack/react-query';\n\nimport type {ProgressiveRefetchInterval, RefetchIntervalFunction} from '../types';\n\nconst BASE = 2;\n\nexport const getProgressiveRefetch = <\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>({\n minInterval,\n maxInterval,\n}: ProgressiveRefetchInterval): RefetchIntervalFunction<TQueryFnData, TError, TData, TQueryKey> => {\n return (_, queryRefetchCount) => {\n return Math.min(minInterval * BASE ** queryRefetchCount, maxInterval);\n };\n};\n"],"mappings":";;;;;;AAIA,IAAMA,IAAI,GAAG,CAAC;AAEP,IAAMC,qBAAqB,GAAAC,OAAA,CAAAD,qBAAA,GAAG,SAAxBA,qBAAqBA,CAAAE,IAAA,EAQiE;EAAA,IAF/FC,WAAW,GAAAD,IAAA,CAAXC,WAAW;IACXC,WAAW,GAAAF,IAAA,CAAXE,WAAW;EAEX,OAAO,UAACC,CAAC,EAAEC,iBAAiB,EAAK;IAC7B,OAAOC,IAAI,CAACC,GAAG,CAACL,WAAW,GAAAI,IAAA,CAAAE,GAAA,CAAGV,IAAI,EAAIO,iBAAiB,GAAEF,WAAW,CAAC;EACzE,CAAC;AACL,CAAC","ignoreList":[]}

package/build/esm/core/index.d.ts CHANGED Viewed

@@ -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/esm/core/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"names":["idle","composeKey","composeFullKey","getError","getStatus","hasTag","mergeStatuses","skipContext","isCancellable","isAbortable","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~~,SAAQA,IAAI,QAAO,aAAa;AAEhC,SAAQC,UAAU,QAAO,oBAAoB;AAC7C,SAAQC,cAAc,QAAO,wBAAwB;AACrD,SAAQC,QAAQ,QAAO,kBAAkB;AACzC,SAAQC,SAAS,QAAO,mBAAmB;AAC3C,SAAQC,MAAM,QAAO,gBAAgB;AACrC,SAAQC,aAAa,QAAO,uBAAuB;AACnD,SAAQC,WAAW,QAAO,qBAAqB;AAE/C,SAAQC,aAAa,EAAEC,WAAW,EAAEC,gBAAgB,QAAO,0BAA0B","ignoreList":[]}
1	+ {"version":3,"names":["idle","composeKey","composeFullKey","getError","getStatus","hasTag","mergeStatuses","skipContext","isCancellable","isAbortable","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,SAAQA,IAAI,QAAO,aAAa;AAEhC,SAAQC,UAAU,QAAO,oBAAoB;AAC7C,SAAQC,cAAc,QAAO,wBAAwB;AACrD,SAAQC,QAAQ,QAAO,kBAAkB;AACzC,SAAQC,SAAS,QAAO,mBAAmB;AAC3C,SAAQC,MAAM,QAAO,gBAAgB;AACrC,SAAQC,aAAa,QAAO,uBAAuB;AACnD,SAAQC,WAAW,QAAO,qBAAqB;AAE/C,SAAQC,aAAa,EAAEC,WAAW,EAAEC,gBAAgB,QAAO,0BAA0B","ignoreList":[]}

package/build/esm/core/types/DataManagerOptions.d.ts ADDED Viewed

@@ -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/esm/core/types/DataManagerOptions.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export {};
2	+ // #sourceMappingURL=DataManagerOptions.js.map

package/build/esm/core/types/DataManagerOptions.js.map ADDED Viewed

	@@ -0,0 +1 @@
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/esm/core/types/DataManger.d.ts CHANGED Viewed

@@ -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/esm/core/types/DataManger.js.map CHANGED Viewed

	@@ -1 +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":[]}
1	+ {"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/esm/react-query/ClientDataManager.d.ts CHANGED Viewed

@@ -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/esm/react-query/ClientDataManager.js CHANGED Viewed

@@ -22,33 +22,33 @@ export var ClientDataManager = /*#__PURE__*/function () {
   }
   return _createClass(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 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 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",
@@ -60,11 +60,11 @@ export var ClientDataManager = /*#__PURE__*/function () {
     }
   }, {
     key: "invalidateParams",
-    value: function invalidateParams(dataSource, params) {
-      return this.queryClient.invalidateQueries({
+    value: function invalidateParams(dataSource, params, invalidateOptions) {
+      return this.invalidateQueries({
         queryKey: composeFullKey(dataSource, params),
         exact: true
-      });
+      }, invalidateOptions);
     }
   }, {
     key: "resetParams",
@@ -76,11 +76,35 @@ export var 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: 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/esm/react-query/ClientDataManager.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"names":["QueryClient","composeFullKey","hasTag","ClientDataManager","_conifg$defaultOption","_conifg$defaultOption2","conifg","arguments","length","undefined","_classCallCheck","queryClient","_objectSpread","defaultOptions","queries","networkMode","mutations","_createClass","key","value","invalidateTag","tag","invalidateQueries","predicate","_ref","queryKey","invalidateTags","tags","_ref2","every","invalidateSource","dataSource","name","resetSource","resetQueries","invalidateParams","params","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":";;;AACA,SAAQA,WAAW,QAAO,uBAAuB;AAEjD,SAKIC,cAAc,EACdC,MAAM,QACH,SAAS;~~AAIhB~~,WAAaC,iBAAiB;EAG1B,SAAAA,kBAAA,EAAkD;IAAA,IAAAC,qBAAA,EAAAC,sBAAA;IAAA,IAAtCC,MAA+B,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;IAAAG,eAAA,OAAAP,iBAAA;IAAA,KAFvCQ,WAAW;IAGhB,IAAI,CAACA,WAAW,GAAG,IAAIX,WAAW,CAAAY,aAAA,CAAAA,aAAA,KAC3BN,MAAM;MACTO,cAAc,EAAAD,aAAA,CAAAA,aAAA,KACPN,MAAM,CAACO,cAAc;QACxBC,OAAO,EAAAF,aAAA;UACHG,WAAW,EAAE;QAAQ,IAAAX,qBAAA,GAClBE,MAAM,CAACO,cAAc,cAAAT,qBAAA,uBAArBA,qBAAA,CAAuBU,OAAO,CACpC;QACDE,SAAS,EAAAJ,aAAA;UACLG,WAAW,EAAE;QAAQ,IAAAV,sBAAA,GAClBC,MAAM,CAACO,cAAc,cAAAR,sBAAA,uBAArBA,sBAAA,CAAuBW,SAAS;MACtC;IACJ,EACJ,CAAC;EACN;EAAC,OAAAC,YAAA,CAAAd,iBAAA;IAAAe,GAAA;IAAAC,KAAA,EAED,SAAAC,aAAaA,CAACC,GAAkB,EAAE;~~MAC9B~~,OAAO,IAAI,~~CAACV~~,~~WAAW,CAACW,~~iBAAiB,~~CAAC~~;~~QACtCC~~,SAAS,EAAE,SAAXA,SAASA,CAAAC,IAAA;UAAA,IAAIC,QAAQ,GAAAD,IAAA,CAARC,QAAQ;UAAA,~~OAAMvB~~,MAAM,~~CAACuB~~,QAAQ,~~EAAEJ~~,GAAG,CAAC;QAAA;MACpD,CAAC,CAAC;~~IACN~~;EAAC;~~IAAAH~~,GAAA;IAAAC,KAAA,EAED,~~SAAAO~~,cAAcA,CAACC,IAAqB,EAAE;~~MAClC~~,OAAO,IAAI,~~CAAChB~~,~~WAAW,CAACW,~~iBAAiB,~~CAAC~~;~~QACtCC~~,SAAS,EAAE,SAAXA,SAASA,CAAAK,KAAA;UAAA,IAAIH,QAAQ,GAAAG,KAAA,CAARH,QAAQ;UAAA,OAAME,IAAI,CAACE,KAAK,CAAC,~~UAACR~~,GAAG;YAAA,OAAKnB,MAAM,~~CAACuB~~,QAAQ,~~EAAEJ~~,GAAG,CAAC;UAAA,EAAC;QAAA;MACzE,CAAC,CAAC;~~IACN~~;EAAC;~~IAAAH~~,GAAA;IAAAC,KAAA,EAED,~~SAAAW~~,gBAAgBA,~~CAAoCC~~,UAAuB,~~EAAE~~;~~MACzE~~,OAAO,IAAI,~~CAACpB~~,~~WAAW,CAACW,~~iBAAiB,~~CAAC~~;~~QACtC~~;QACAG,QAAQ,EAAE,CAACM,UAAU,CAACC,IAAI;MAC9B,CAAC,CAAC;~~IACN~~;EAAC;~~IAAAd~~,GAAA;IAAAC,KAAA,EAED,~~SAAAc~~,WAAWA,CAAoCF,UAAuB,EAAE;MACpE,OAAO,IAAI,~~CAACpB~~,WAAW,~~CAACuB~~,YAAY,CAAC;QACjC;QACAT,QAAQ,EAAE,CAACM,UAAU,CAACC,IAAI;MAC9B,CAAC,CAAC;IACN;EAAC;~~IAAAd~~,GAAA;IAAAC,KAAA,EAED,~~SAAAgB~~,gBAAgBA,CACZJ,UAAuB,EACvBK,MAAqC,EACvC;MACE,OAAO,IAAI,~~CAACzB~~,~~WAAW,CAACW,~~iBAAiB,~~CAAC~~;~~QACtCG~~,QAAQ,~~EAAExB~~,cAAc,~~CAAC8B~~,UAAU,EAAEK,MAAM,CAAC;QAC5CC,KAAK,EAAE;MACX,CAAC,CAAC;~~IACN~~;EAAC;~~IAAAnB~~,GAAA;IAAAC,KAAA,EAED,~~SAAAmB~~,WAAWA,CACPP,UAAuB,EACvBK,MAAqC,EACvC;MACE,OAAO,IAAI,~~CAACzB~~,WAAW,~~CAACuB~~,YAAY,CAAC;QACjCT,QAAQ,~~EAAExB~~,cAAc,~~CAAC8B~~,UAAU,EAAEK,MAAM,CAAC;QAC5CC,KAAK,EAAE;MACX,CAAC,CAAC;IACN;EAAC;~~IAAAnB~~,GAAA;IAAAC,KAAA,EAED,~~SAAAoB~~,oBAAoBA,CAChBR,UAAuB,EACvBK,MAAqC,EACvC;MACE,OAAO,IAAI,~~CAACzB~~,~~WAAW,CAACW,~~iBAAiB,~~CAAC~~;~~QACtC~~;QACAG,QAAQ,~~EAAExB~~,cAAc,~~CAAC8B~~,UAAU,EAAEK,MAAM,CAAC,CAACI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;MAC5D,CAAC,CAAC;~~IACN~~;EAAC;AAAA","ignoreList":[]}
1	+ {"version":3,"names":["QueryClient","composeFullKey","hasTag","ClientDataManager","_conifg$defaultOption","_conifg$defaultOption2","conifg","arguments","length","undefined","_classCallCheck","queryClient","_objectSpread","defaultOptions","queries","networkMode","mutations","_createClass","key","value","invalidateTag","tag","invalidateOptions","invalidateQueries","predicate","_ref","queryKey","invalidateTags","tags","_ref2","every","invalidateSource","dataSource","name","resetSource","resetQueries","invalidateParams","params","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/esm/react-query/hooks/useQueryData.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"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":[]}
1	+ {"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 {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,SAAQA,oBAAoB,QAAO,wBAAwB;AAE3D,SAAQC,iBAAiB,QAAO,qBAAqB;AAGrD,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,CACrBO,OAAO,EACPH,UAAU,EACVC,MAAM,EACNC,OACJ,CAAC;EACL,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/hooks/useRefetchInterval.d.ts ADDED Viewed

@@ -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/esm/react-query/hooks/useRefetchInterval.js ADDED Viewed

@@ -0,0 +1,26 @@
+import React from 'react';
+export var useRefetchInterval = function useRefetchInterval(refetchIntervalOption, queryFnOption) {
+  var count = React.useRef(0);
+  var queryFn = React.useMemo(function () {
+    if (typeof queryFnOption === 'function') {
+      return function (context) {
+        count.current++;
+        return queryFnOption(context);
+      };
+    }
+    return undefined;
+  }, [queryFnOption]);
+  var refetchInterval = React.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/esm/react-query/hooks/useRefetchInterval.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"names":["React","useRefetchInterval","refetchIntervalOption","queryFnOption","count","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,OAAOA,KAAK,MAAM,OAAO;AAOzB,OAAO,IAAMC,kBAAkB,GAAG,SAArBA,kBAAkBA,CAC3BC,qBAKC,EACDC,aAEe,EAgBd;EACD,IAAMC,KAAK,GAAGJ,KAAK,CAACK,MAAM,CAAS,CAAC,CAAC;EAErC,IAAMC,OAAO,GAAGN,KAAK,CAACO,OAAO,CAAC,YAAM;IAChC,IAAI,OAAOJ,aAAa,KAAK,UAAU,EAAE;MACrC,OAAO,UAACK,OAAyD,EAAK;QAClEJ,KAAK,CAACK,OAAO,EAAE;QACf,OAAON,aAAa,CAACK,OAAO,CAAC;MACjC,CAAC;IACL;IACA,OAAOE,SAAS;EACpB,CAAC,EAAE,CAACP,aAAa,CAAC,CAAC;EAEnB,IAAMQ,eAAe,GAAGX,KAAK,CAACO,OAAO,CAAC,YAAM;IACxC,IAAI,OAAOL,qBAAqB,KAAK,UAAU,EAAE;MAC7C,OAAO,UACHU,KAKC,EACA;QACD,OAAOV,qBAAqB,CAACU,KAAK,EAAER,KAAK,CAACK,OAAO,CAAC;MACtD,CAAC;IACL;IACA,OAAOP,qBAAqB;EAChC,CAAC,EAAE,CAACA,qBAAqB,CAAC,CAAC;EAE3B,OAAO;IAACS,eAAe,EAAfA,eAAe;IAAEL,OAAO,EAAPA;EAAO,CAAC;AACrC,CAAC","ignoreList":[]}

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

@@ -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/esm/react-query/impl/infinite/hooks.js CHANGED Viewed

@@ -1,8 +1,37 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+var _excluded = ["refetchInterval", "queryFn"];
+import { useMemo } from 'react';
 import { useInfiniteQuery } from '@tanstack/react-query';
-import { composeOptions, transformResult } from './utils';
+import { useRefetchInterval } from '../../hooks/useRefetchInterval';
+import { normalizeStatus } from '../../utils/normalizeStatus';
+import { composeOptions } from './utils';
 export var useInfiniteQueryData = function useInfiniteQueryData(context, dataSource, params, options) {
   var composedOptions = composeOptions(context, dataSource, params, options);
-  var result = useInfiniteQuery(composedOptions);
-  return transformResult(result);
+  var extendedOptions = useInfiniteQueryDataOptions(composedOptions);
+  var result = useInfiniteQuery(extendedOptions);
+  var transformedData = 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 _objectSpread(_objectSpread({}, result), {}, {
+    status: normalizeStatus(result.status, result.fetchStatus),
+    data: transformedData,
+    originalStatus: result.status,
+    originalData: result.data
+  });
 };
+export function useInfiniteQueryDataOptions(composedOptions) {
+  var _ref = composedOptions || {},
+    refetchIntervalOption = _ref.refetchInterval,
+    queryFnOption = _ref.queryFn,
+    restOptions = _objectWithoutProperties(_ref, _excluded);
+  var _useRefetchInterval = useRefetchInterval(refetchIntervalOption, queryFnOption),
+    refetchInterval = _useRefetchInterval.refetchInterval,
+    queryFn = _useRefetchInterval.queryFn;
+  return _objectSpread(_objectSpread({}, restOptions), {}, {
+    refetchInterval: refetchInterval,
+    queryFn: queryFn
+  });
+}
 // #sourceMappingURL=hooks.js.map

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

	@@ -1 +1 @@
1	- {"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":[]}
1	+ {"version":3,"names":["useMemo","useInfiniteQuery","useRefetchInterval","normalizeStatus","composeOptions","useInfiniteQueryData","context","dataSource","params","options","composedOptions","extendedOptions","useInfiniteQueryDataOptions","result","transformedData","_result$data$pages$fl","_result$data","data","pages","flat","_objectSpread","status","fetchStatus","originalStatus","originalData","_ref","refetchIntervalOption","refetchInterval","queryFnOption","queryFn","restOptions","_objectWithoutProperties","_excluded","_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,SAAQA,OAAO,QAAO,OAAO;AAE7B,SAAQC,gBAAgB,QAAO,uBAAuB;AAatD,SAAQC,kBAAkB,QAAO,gCAAgC;AACjE,SAAQC,eAAe,QAAO,6BAA6B;AAO3D,SAAQC,cAAc,QAAO,SAAS;AAEtC,OAAO,IAAMC,oBAAoB,GAAG,SAAvBA,oBAAoBA,CAC7BC,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAiD,EAClB;EAC/B,IAAMC,eAAe,GAAGN,cAAc,CAACE,OAAO,EAAEC,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EAE5E,IAAME,eAAe,GAAGC,2BAA2B,CAACF,eAAe,CAAC;EAEpE,IAAMG,MAAM,GAAGZ,gBAAgB,CAACU,eAAe,CAAC;EAEhD,IAAMG,eAAe,GAAGd,OAAO,CAC3B;IAAA,IAAAe,qBAAA,EAAAC,YAAA;IAAA,QAAAD,qBAAA,IAAAC,YAAA,GAAMH,MAAM,CAACI,IAAI,cAAAD,YAAA,uBAAXA,YAAA,CAAaE,KAAK,CAACC,IAAI,CAAC,CAAC,CAAC,cAAAJ,qBAAA,cAAAA,qBAAA,GAAI,EAAE;EAAA,GACtC,CAACF,MAAM,CAACI,IAAI,CAChB,CAAC;EAED,OAAAG,aAAA,CAAAA,aAAA,KACOP,MAAM;IACTQ,MAAM,EAAElB,eAAe,CAACU,MAAM,CAACQ,MAAM,EAAER,MAAM,CAACS,WAAW,CAAC;IAC1DL,IAAI,EAAEH,eAAe;IACrBS,cAAc,EAAEV,MAAM,CAACQ,MAAM;IAC7BG,YAAY,EAAEX,MAAM,CAACI;EAAI;AAEjC,CAAC;AAED,OAAO,SAASL,2BAA2BA,CACvCF,eAOC,EAQH;EACE,IAAAe,IAAA,GAIIf,eAAe,IAAI,CAAC,CAAC;IAHJgB,qBAAqB,GAAAD,IAAA,CAAtCE,eAAe;IACNC,aAAa,GAAAH,IAAA,CAAtBI,OAAO;IACJC,WAAW,GAAAC,wBAAA,CAAAN,IAAA,EAAAO,SAAA;EAGlB,IAAAC,mBAAA,GAAmC/B,kBAAkB,CAACwB,qBAAqB,EAAEE,aAAa,CAAC;IAApFD,eAAe,GAAAM,mBAAA,CAAfN,eAAe;IAAEE,OAAO,GAAAI,mBAAA,CAAPJ,OAAO;EAE/B,OAAAT,aAAA,CAAAA,aAAA,KAAWU,WAAW;IAAEH,eAAe,EAAfA,eAAe;IAAEE,OAAO,EAAPA;EAAO;AACpD","ignoreList":[]}