@gravity-ui/data-source 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","useRefetchAll","exports","states","useCallback","forEach","_ref","refetch","map","_ref2"],"sources":["useRefetchAll.ts"],"sourcesContent":["import {useCallback} from 'react';\n\nexport const useRefetchAll = (states: {refetch: Function}[]) => {\n    return useCallback(\n        () => states.forEach(({refetch}) => refetch()),\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        states.map(({refetch}) => refetch),\n    );\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEO,IAAMC,aAAa,GAAAC,OAAA,CAAAD,aAAA,GAAG,SAAhBA,aAAaA,CAAIE,MAA6B,EAAK;EAC5D,OAAO,IAAAC,kBAAW,EACd;IAAA,OAAMD,MAAM,CAACE,OAAO,CAAC,UAAAC,IAAA;MAAA,IAAEC,OAAO,GAAAD,IAAA,CAAPC,OAAO;MAAA,OAAMA,OAAO,CAAC,CAAC;IAAA,EAAC;EAAA;EAC9C;EACAJ,MAAM,CAACK,GAAG,CAAC,UAAAC,KAAA;IAAA,IAAEF,OAAO,GAAAE,KAAA,CAAPF,OAAO;IAAA,OAAMA,OAAO;EAAA,EACrC,CAAC;AACL,CAAC","ignoreList":[]}

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

@@ -0,0 +1,4 @@
+export declare const useRefetchErrored: <TError>(states: {
+    error: TError | null;
+    refetch: Function;
+}[]) => () => void;

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

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useRefetchErrored = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _react = require("react");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var useRefetchErrored = exports.useRefetchErrored = function useRefetchErrored(states) {
+  return (0, _react.useCallback)(function () {
+    return states.forEach(function (_ref) {
+      var error = _ref.error,
+        refetch = _ref.refetch;
+      return error && refetch();
+    });
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  states.reduce(function (acc, _ref2) {
+    var error = _ref2.error,
+      refetch = _ref2.refetch;
+    return [].concat((0, _toConsumableArray2.default)(acc), [error, refetch]);
+  }, []));
+};
+// #sourceMappingURL=useRefetchErrored.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_interopRequireDefault","e","__esModule","default","useRefetchErrored","exports","states","useCallback","forEach","_ref","error","refetch","reduce","acc","_ref2","concat","_toConsumableArray"],"sources":["useRefetchErrored.ts"],"sourcesContent":["import type {DependencyList} from 'react';\nimport {useCallback} from 'react';\n\nexport const useRefetchErrored = <TError>(states: {error: TError | null; refetch: Function}[]) => {\n    return useCallback(\n        () => states.forEach(({error, refetch}) => error && refetch()),\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        states.reduce<DependencyList>((acc, {error, refetch}) => [...acc, error, refetch], []),\n    );\n};\n"],"mappings":";;;;;;;AACA,IAAAA,MAAA,GAAAC,OAAA;AAAiC,SAAAC,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAE1B,IAAMG,iBAAiB,GAAAC,OAAA,CAAAD,iBAAA,GAAG,SAApBA,iBAAiBA,CAAYE,MAAmD,EAAK;EAC9F,OAAO,IAAAC,kBAAW,EACd;IAAA,OAAMD,MAAM,CAACE,OAAO,CAAC,UAAAC,IAAA;MAAA,IAAEC,KAAK,GAAAD,IAAA,CAALC,KAAK;QAAEC,OAAO,GAAAF,IAAA,CAAPE,OAAO;MAAA,OAAMD,KAAK,IAAIC,OAAO,CAAC,CAAC;IAAA,EAAC;EAAA;EAC9D;EACAL,MAAM,CAACM,MAAM,CAAiB,UAACC,GAAG,EAAAC,KAAA;IAAA,IAAGJ,KAAK,GAAAI,KAAA,CAALJ,KAAK;MAAEC,OAAO,GAAAG,KAAA,CAAPH,OAAO;IAAA,UAAAI,MAAA,KAAAC,2BAAA,EAAUH,GAAG,IAAEH,KAAK,EAAEC,OAAO;EAAA,CAAC,EAAE,EAAE,CACzF,CAAC;AACL,CAAC","ignoreList":[]}

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeInfiniteQueryDataSource = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var makeInfiniteQueryDataSource = exports.makeInfiniteQueryDataSource = function makeInfiniteQueryDataSource(config) {
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, config), {}, {
+    type: 'infinite'
+  });
+};
+// #sourceMappingURL=factory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["makeInfiniteQueryDataSource","exports","config","_objectSpread","type"],"sources":["factory.ts"],"sourcesContent":["import type {InfiniteQueryDataSource} from './types';\n\nexport const makeInfiniteQueryDataSource = <TParams, TRequest, TResponse, TData, TError>(\n    config: Omit<InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError>, 'type'>,\n): InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError> => ({\n    ...config,\n    type: 'infinite',\n});\n"],"mappings":";;;;;;;;AAEO,IAAMA,2BAA2B,GAAAC,OAAA,CAAAD,2BAAA,GAAG,SAA9BA,2BAA2BA,CACpCE,MAA0F;EAAA,WAAAC,sBAAA,MAAAA,sBAAA,MAEvFD,MAAM;IACTE,IAAI,EAAE;EAAU;AAAA,CAClB","ignoreList":[]}

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useInfiniteQueryData = void 0;
+var _react = require("react");
+var _reactQuery = require("@tanstack/react-query");
+var _utils = require("./utils");
+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, _react.useMemo)(function () {
+    return (0, _utils.transformResult)(result);
+  }, [result]);
+};
+// #sourceMappingURL=hooks.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_reactQuery","_utils","useInfiniteQueryData","exports","context","dataSource","params","options","composedOptions","composeOptions","result","useInfiniteQuery","useMemo","transformResult"],"sources":["hooks.ts"],"sourcesContent":["import {useMemo} from 'react';\n\nimport {useInfiniteQuery} from '@tanstack/react-query';\n\nimport type {DataSourceContext, DataSourceOptions, DataSourceParams} from '../../../core';\n\nimport type {AnyInfiniteQueryDataSource} from './types';\nimport {composeOptions, transformResult} from './utils';\n\nexport const useInfiniteQueryData = <TDataSource extends AnyInfiniteQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: DataSourceOptions<TDataSource>,\n) => {\n    const composedOptions = composeOptions(context, dataSource, params, options);\n    const result = useInfiniteQuery(composedOptions);\n\n    return useMemo(() => transformResult(result), [result]);\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,WAAA,GAAAD,OAAA;AAKA,IAAAE,MAAA,GAAAF,OAAA;AAEO,IAAMG,oBAAoB,GAAAC,OAAA,CAAAD,oBAAA,GAAG,SAAvBA,oBAAoBA,CAC7BE,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAwC,EACvC;EACD,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,cAAO,EAAC;IAAA,OAAM,IAAAC,sBAAe,EAACH,MAAM,CAAC;EAAA,GAAE,CAACA,MAAM,CAAC,CAAC;AAC3D,CAAC","ignoreList":[]}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformResult = exports.composeOptions = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _core = require("../../../core");
+var _normalizeStatus = require("../../utils/normalizeStatus");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var EMPTY_ARRAY = [];
+var composeOptions = exports.composeOptions = function composeOptions(context, dataSource, params, options) {
+  var transformParams = dataSource.transformParams,
+    transformResponse = dataSource.transformResponse,
+    next = dataSource.next,
+    prev = dataSource.prev;
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, dataSource.options), {}, {
+    enabled: params !== _core.idle,
+    queryKey: (0, _core.composeFullKey)(dataSource, params),
+    queryFn: function queryFn(fetchContext) {
+      var _fetchContext$pagePar;
+      var actualParams = (_fetchContext$pagePar = fetchContext.pageParam) !== null && _fetchContext$pagePar !== void 0 ? _fetchContext$pagePar : params;
+      return dataSource.fetch(context, fetchContext, transformParams ? transformParams(actualParams) : actualParams);
+    },
+    select: transformResponse ? function (data) {
+      return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, data), {}, {
+        pages: data.pages.map(transformResponse)
+      });
+    } : undefined,
+    getNextPageParam: function getNextPageParam(lastPage, allPages) {
+      var nextParamsPatch = next(lastPage, allPages);
+      return nextParamsPatch ? (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), nextParamsPatch) : undefined;
+    },
+    getPreviousPageParam: prev ? function (firstPage, allPages) {
+      var prevParamsPatch = prev(firstPage, allPages);
+      return prevParamsPatch ? (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), prevParamsPatch) : undefined;
+    } : undefined
+  }, 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()) !== 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

@@ -0,0 +1 @@
+{"version":3,"names":["_core","require","_normalizeStatus","_interopRequireDefault","e","__esModule","default","EMPTY_ARRAY","composeOptions","exports","context","dataSource","params","options","transformParams","transformResponse","next","prev","_objectSpread","enabled","idle","queryKey","composeFullKey","queryFn","fetchContext","_fetchContext$pagePar","actualParams","pageParam","fetch","select","data","pages","map","undefined","getNextPageParam","lastPage","allPages","nextParamsPatch","getPreviousPageParam","firstPage","prevParamsPatch","transformResult","result","_result$data$pages$fl","_result$data","status","normalizeStatus","fetchStatus","flat","originalStatus","originalData"],"sources":["utils.ts"],"sourcesContent":["import type {\n    InfiniteQueryObserverOptions,\n    InfiniteQueryObserverResult,\n    QueryFunctionContext,\n} from '@tanstack/react-query';\n\nimport {\n    type DataSourceContext,\n    type DataSourceData,\n    type DataSourceError,\n    type DataSourceKey,\n    type DataSourceOptions,\n    type DataSourceParams,\n    type DataSourceResponse,\n    type DataSourceState,\n    composeFullKey,\n    idle,\n} from '../../../core';\nimport {normalizeStatus} from '../../utils/normalizeStatus';\n\nimport type {AnyInfiniteQueryDataSource} from './types';\n\nconst EMPTY_ARRAY: unknown[] = [];\n\nexport const composeOptions = <TDataSource extends AnyInfiniteQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: DataSourceOptions<TDataSource>,\n): InfiniteQueryObserverOptions<\n    DataSourceResponse<TDataSource>,\n    DataSourceError<TDataSource>,\n    DataSourceData<TDataSource>,\n    DataSourceResponse<TDataSource>\n> => {\n    const {transformParams, transformResponse, next, prev} = dataSource;\n\n    return {\n        ...dataSource.options,\n        enabled: params !== idle,\n        queryKey: composeFullKey(dataSource, params),\n        queryFn: (\n            fetchContext: QueryFunctionContext<DataSourceKey, DataSourceParams<TDataSource>>,\n        ) => {\n            const actualParams = fetchContext.pageParam ?? params;\n\n            return dataSource.fetch(\n                context,\n                fetchContext,\n                transformParams ? transformParams(actualParams) : actualParams,\n            );\n        },\n        select: transformResponse\n            ? (data) => ({...data, pages: data.pages.map(transformResponse)})\n            : undefined,\n        getNextPageParam: (lastPage, allPages) => {\n            const nextParamsPatch = next(lastPage, allPages);\n\n            return nextParamsPatch ? {...params, ...nextParamsPatch} : undefined;\n        },\n        getPreviousPageParam: prev\n            ? (firstPage, allPages) => {\n                  const prevParamsPatch = prev(firstPage, allPages);\n\n                  return prevParamsPatch ? {...params, ...prevParamsPatch} : undefined;\n              }\n            : undefined,\n        ...options,\n    };\n};\n\nexport const transformResult = <TDataSource extends AnyInfiniteQueryDataSource>(\n    result: InfiniteQueryObserverResult<DataSourceData<TDataSource>, DataSourceError<TDataSource>>,\n) => {\n    return {\n        ...result,\n        status: normalizeStatus(result.status, result.fetchStatus),\n        data: result.data?.pages.flat() ?? EMPTY_ARRAY,\n        originalStatus: result.status,\n        originalData: result.data,\n    } as DataSourceState<TDataSource>;\n};\n"],"mappings":";;;;;;;AAMA,IAAAA,KAAA,GAAAC,OAAA;AAYA,IAAAC,gBAAA,GAAAD,OAAA;AAA2D,SAAAE,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAI3D,IAAMG,WAAsB,GAAG,EAAE;AAE1B,IAAMC,cAAc,GAAAC,OAAA,CAAAD,cAAA,GAAG,SAAjBA,cAAcA,CACvBE,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAwC,EAMvC;EACD,IAAOC,eAAe,GAAmCH,UAAU,CAA5DG,eAAe;IAAEC,iBAAiB,GAAgBJ,UAAU,CAA3CI,iBAAiB;IAAEC,IAAI,GAAUL,UAAU,CAAxBK,IAAI;IAAEC,IAAI,GAAIN,UAAU,CAAlBM,IAAI;EAErD,WAAAC,sBAAA,MAAAA,sBAAA,MACOP,UAAU,CAACE,OAAO;IACrBM,OAAO,EAAEP,MAAM,KAAKQ,UAAI;IACxBC,QAAQ,EAAE,IAAAC,oBAAc,EAACX,UAAU,EAAEC,MAAM,CAAC;IAC5CW,OAAO,EAAE,SAATA,OAAOA,CACHC,YAAgF,EAC/E;MAAA,IAAAC,qBAAA;MACD,IAAMC,YAAY,IAAAD,qBAAA,GAAGD,YAAY,CAACG,SAAS,cAAAF,qBAAA,cAAAA,qBAAA,GAAIb,MAAM;MAErD,OAAOD,UAAU,CAACiB,KAAK,CACnBlB,OAAO,EACPc,YAAY,EACZV,eAAe,GAAGA,eAAe,CAACY,YAAY,CAAC,GAAGA,YACtD,CAAC;IACL,CAAC;IACDG,MAAM,EAAEd,iBAAiB,GACnB,UAACe,IAAI;MAAA,WAAAZ,sBAAA,MAAAA,sBAAA,MAAUY,IAAI;QAAEC,KAAK,EAAED,IAAI,CAACC,KAAK,CAACC,GAAG,CAACjB,iBAAiB;MAAC;IAAA,CAAE,GAC/DkB,SAAS;IACfC,gBAAgB,EAAE,SAAlBA,gBAAgBA,CAAGC,QAAQ,EAAEC,QAAQ,EAAK;MACtC,IAAMC,eAAe,GAAGrB,IAAI,CAACmB,QAAQ,EAAEC,QAAQ,CAAC;MAEhD,OAAOC,eAAe,OAAAnB,sBAAA,MAAAA,sBAAA,MAAON,MAAM,GAAKyB,eAAe,IAAIJ,SAAS;IACxE,CAAC;IACDK,oBAAoB,EAAErB,IAAI,GACpB,UAACsB,SAAS,EAAEH,QAAQ,EAAK;MACrB,IAAMI,eAAe,GAAGvB,IAAI,CAACsB,SAAS,EAAEH,QAAQ,CAAC;MAEjD,OAAOI,eAAe,OAAAtB,sBAAA,MAAAA,sBAAA,MAAON,MAAM,GAAK4B,eAAe,IAAIP,SAAS;IACxE,CAAC,GACDA;EAAS,GACZpB,OAAO;AAElB,CAAC;AAEM,IAAM4B,eAAe,GAAAhC,OAAA,CAAAgC,eAAA,GAAG,SAAlBA,eAAeA,CACxBC,MAA8F,EAC7F;EAAA,IAAAC,qBAAA,EAAAC,YAAA;EACD,WAAA1B,sBAAA,MAAAA,sBAAA,MACOwB,MAAM;IACTG,MAAM,EAAE,IAAAC,gCAAe,EAACJ,MAAM,CAACG,MAAM,EAAEH,MAAM,CAACK,WAAW,CAAC;IAC1DjB,IAAI,GAAAa,qBAAA,IAAAC,YAAA,GAAEF,MAAM,CAACZ,IAAI,cAAAc,YAAA,uBAAXA,YAAA,CAAab,KAAK,CAACiB,IAAI,CAAC,CAAC,cAAAL,qBAAA,cAAAA,qBAAA,GAAIpC,WAAW;IAC9C0C,cAAc,EAAEP,MAAM,CAACG,MAAM;IAC7BK,YAAY,EAAER,MAAM,CAACZ;EAAI;AAEjC,CAAC","ignoreList":[]}

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makePlainQueryDataSource = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var makePlainQueryDataSource = exports.makePlainQueryDataSource = function makePlainQueryDataSource(config) {
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, config), {}, {
+    type: 'plain'
+  });
+};
+// #sourceMappingURL=factory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["makePlainQueryDataSource","exports","config","_objectSpread","type"],"sources":["factory.ts"],"sourcesContent":["import type {PlainQueryDataSource} from './types';\n\nexport const makePlainQueryDataSource = <TParams, TRequest, TResponse, TData, TError>(\n    config: Omit<PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError>, 'type'>,\n): PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError> => ({\n    ...config,\n    type: 'plain',\n});\n"],"mappings":";;;;;;;;AAEO,IAAMA,wBAAwB,GAAAC,OAAA,CAAAD,wBAAA,GAAG,SAA3BA,wBAAwBA,CACjCE,MAAuF;EAAA,WAAAC,sBAAA,MAAAA,sBAAA,MAEpFD,MAAM;IACTE,IAAI,EAAE;EAAO;AAAA,CACf","ignoreList":[]}

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePlainQueryData = void 0;
+var _react = require("react");
+var _reactQuery = require("@tanstack/react-query");
+var _utils = require("./utils");
+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, _react.useMemo)(function () {
+    return (0, _utils.transformResult)(result);
+  }, [result]);
+};
+// #sourceMappingURL=hooks.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_reactQuery","_utils","usePlainQueryData","exports","context","dataSource","params","options","composedOptions","composeOptions","result","useQuery","useMemo","transformResult"],"sources":["hooks.ts"],"sourcesContent":["import {useMemo} from 'react';\n\nimport {useQuery} from '@tanstack/react-query';\n\nimport type {DataSourceContext, DataSourceOptions, DataSourceParams} from '../../../core';\n\nimport type {AnyPlainQueryDataSource} from './types';\nimport {composeOptions, transformResult} from './utils';\n\nexport const usePlainQueryData = <TDataSource extends AnyPlainQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: DataSourceOptions<TDataSource>,\n) => {\n    const composedOptions = composeOptions(context, dataSource, params, options);\n    const result = useQuery(composedOptions);\n\n    return useMemo(() => transformResult(result), [result]);\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,WAAA,GAAAD,OAAA;AAKA,IAAAE,MAAA,GAAAF,OAAA;AAEO,IAAMG,iBAAiB,GAAAC,OAAA,CAAAD,iBAAA,GAAG,SAApBA,iBAAiBA,CAC1BE,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAwC,EACvC;EACD,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,cAAO,EAAC;IAAA,OAAM,IAAAC,sBAAe,EAACH,MAAM,CAAC;EAAA,GAAE,CAACA,MAAM,CAAC,CAAC;AAC3D,CAAC","ignoreList":[]}

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

@@ -0,0 +1,14 @@
+import type { QueryFunctionContext, 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>>, ResultWrapper<QueryObserverResult<ActualData<TData, TResponse>, TError>>, QueryFunctionContext<DataSourceKey, unknown>> & {
+    type: 'plain';
+};
+export type AnyPlainQueryDataSource = PlainQueryDataSource<any, any, any, any, any>;
+type ResultWrapper<T> = T extends QueryObserverResult ? Overwrite<T, {
+    status: DataLoaderStatus;
+}> & {
+    originalStatus: T['status'];
+} : never;
+export {};

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

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

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

@@ -0,0 +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>>,\n    ResultWrapper<QueryObserverResult<ActualData<TData, TResponse>, TError>>,\n    QueryFunctionContext<DataSourceKey, unknown>\n> & {\n    type: 'plain';\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyPlainQueryDataSource = PlainQueryDataSource<any, any, any, any, any>;\n\ntype ResultWrapper<T> = T extends QueryObserverResult\n    ? Overwrite<T, {status: DataLoaderStatus}> & {originalStatus: T['status']}\n    : never;\n"],"mappings":"","ignoreList":[]}

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

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

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

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformResult = exports.composeOptions = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+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;
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, dataSource.options), {}, {
+    enabled: params !== _core.idle,
+    queryKey: (0, _core.composeFullKey)(dataSource, params),
+    queryFn: function queryFn(fetchContext) {
+      return dataSource.fetch(context, fetchContext, transformParams ? transformParams(params) : params);
+    },
+    select: dataSource.transformResponse
+  }, 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

@@ -0,0 +1 @@
+{"version":3,"names":["_core","require","_normalizeStatus","_interopRequireDefault","e","__esModule","default","composeOptions","exports","context","dataSource","params","options","transformParams","_objectSpread","enabled","idle","queryKey","composeFullKey","queryFn","fetchContext","fetch","select","transformResponse","transformResult","result","status","normalizeStatus","fetchStatus","originalStatus"],"sources":["utils.ts"],"sourcesContent":["import type {\n    QueryFunctionContext,\n    QueryObserverOptions,\n    QueryObserverResult,\n} from '@tanstack/react-query';\n\nimport {composeFullKey, idle} from '../../../core';\nimport type {\n    DataSourceContext,\n    DataSourceData,\n    DataSourceError,\n    DataSourceKey,\n    DataSourceOptions,\n    DataSourceParams,\n    DataSourceResponse,\n    DataSourceState,\n} from '../../../core';\nimport {normalizeStatus} from '../../utils/normalizeStatus';\n\nimport type {AnyPlainQueryDataSource} from './types';\n\nexport const composeOptions = <TDataSource extends AnyPlainQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: DataSourceOptions<TDataSource>,\n): QueryObserverOptions<\n    DataSourceResponse<TDataSource>,\n    DataSourceError<TDataSource>,\n    DataSourceData<TDataSource>,\n    DataSourceResponse<TDataSource>\n> => {\n    const {transformParams} = dataSource;\n\n    return {\n        ...dataSource.options,\n        enabled: params !== idle,\n        queryKey: composeFullKey(dataSource, params),\n        queryFn: (fetchContext: QueryFunctionContext<DataSourceKey, unknown>) =>\n            dataSource.fetch(\n                context,\n                fetchContext,\n                transformParams ? transformParams(params) : params,\n            ),\n        select: dataSource.transformResponse,\n        ...options,\n    };\n};\n\nexport const transformResult = <TDataSource extends AnyPlainQueryDataSource>(\n    result: QueryObserverResult<DataSourceData<TDataSource>, DataSourceError<TDataSource>>,\n) => {\n    return {\n        ...result,\n        status: normalizeStatus(result.status, result.fetchStatus),\n        originalStatus: result.status,\n    } as DataSourceState<TDataSource>;\n};\n"],"mappings":";;;;;;;AAMA,IAAAA,KAAA,GAAAC,OAAA;AAWA,IAAAC,gBAAA,GAAAD,OAAA;AAA2D,SAAAE,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,OAAwC,EAMvC;EACD,IAAOC,eAAe,GAAIH,UAAU,CAA7BG,eAAe;EAEtB,WAAAC,sBAAA,MAAAA,sBAAA,MACOJ,UAAU,CAACE,OAAO;IACrBG,OAAO,EAAEJ,MAAM,KAAKK,UAAI;IACxBC,QAAQ,EAAE,IAAAC,oBAAc,EAACR,UAAU,EAAEC,MAAM,CAAC;IAC5CQ,OAAO,EAAE,SAATA,OAAOA,CAAGC,YAA0D;MAAA,OAChEV,UAAU,CAACW,KAAK,CACZZ,OAAO,EACPW,YAAY,EACZP,eAAe,GAAGA,eAAe,CAACF,MAAM,CAAC,GAAGA,MAChD,CAAC;IAAA;IACLW,MAAM,EAAEZ,UAAU,CAACa;EAAiB,GACjCX,OAAO;AAElB,CAAC;AAEM,IAAMY,eAAe,GAAAhB,OAAA,CAAAgB,eAAA,GAAG,SAAlBA,eAAeA,CACxBC,MAAsF,EACrF;EACD,WAAAX,sBAAA,MAAAA,sBAAA,MACOW,MAAM;IACTC,MAAM,EAAE,IAAAC,gCAAe,EAACF,MAAM,CAACC,MAAM,EAAED,MAAM,CAACG,WAAW,CAAC;IAC1DC,cAAc,EAAEJ,MAAM,CAACC;EAAM;AAErC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,15 @@
+export type { QueryDataSourceContext, AnyQueryDataSource } from './types';
+export { useQueryContext } from './hooks/useQueryContext';
+export { useQueryData } from './hooks/useQueryData';
+export { useQueryResponses } from './hooks/useQueryResponses';
+export { useRefetchAll } from './hooks/useRefetchAll';
+export { useRefetchErrored } from './hooks/useRefetchErrored';
+export type { InfiniteQueryDataSource, AnyInfiniteQueryDataSource } from './impl/infinite/types';
+export { makeInfiniteQueryDataSource } from './impl/infinite/factory';
+export { composeOptions as composeInfiniteQueryOptions } from './impl/infinite/utils';
+export type { PlainQueryDataSource, AnyPlainQueryDataSource } from './impl/plain/types';
+export { makePlainQueryDataSource } from './impl/plain/factory';
+export { composeOptions as composePlainQueryOptions } from './impl/plain/utils';
+export { normalizeStatus } from './utils/normalizeStatus';
+export type { ClientDataManagerConfig } from './ClientDataManager';
+export { ClientDataManager } from './ClientDataManager';

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

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ClientDataManager", {
+  enumerable: true,
+  get: function () {
+    return _ClientDataManager.ClientDataManager;
+  }
+});
+Object.defineProperty(exports, "composeInfiniteQueryOptions", {
+  enumerable: true,
+  get: function () {
+    return _utils.composeOptions;
+  }
+});
+Object.defineProperty(exports, "composePlainQueryOptions", {
+  enumerable: true,
+  get: function () {
+    return _utils2.composeOptions;
+  }
+});
+Object.defineProperty(exports, "makeInfiniteQueryDataSource", {
+  enumerable: true,
+  get: function () {
+    return _factory.makeInfiniteQueryDataSource;
+  }
+});
+Object.defineProperty(exports, "makePlainQueryDataSource", {
+  enumerable: true,
+  get: function () {
+    return _factory2.makePlainQueryDataSource;
+  }
+});
+Object.defineProperty(exports, "normalizeStatus", {
+  enumerable: true,
+  get: function () {
+    return _normalizeStatus.normalizeStatus;
+  }
+});
+Object.defineProperty(exports, "useQueryContext", {
+  enumerable: true,
+  get: function () {
+    return _useQueryContext.useQueryContext;
+  }
+});
+Object.defineProperty(exports, "useQueryData", {
+  enumerable: true,
+  get: function () {
+    return _useQueryData.useQueryData;
+  }
+});
+Object.defineProperty(exports, "useQueryResponses", {
+  enumerable: true,
+  get: function () {
+    return _useQueryResponses.useQueryResponses;
+  }
+});
+Object.defineProperty(exports, "useRefetchAll", {
+  enumerable: true,
+  get: function () {
+    return _useRefetchAll.useRefetchAll;
+  }
+});
+Object.defineProperty(exports, "useRefetchErrored", {
+  enumerable: true,
+  get: function () {
+    return _useRefetchErrored.useRefetchErrored;
+  }
+});
+var _useQueryContext = require("./hooks/useQueryContext");
+var _useQueryData = require("./hooks/useQueryData");
+var _useQueryResponses = require("./hooks/useQueryResponses");
+var _useRefetchAll = require("./hooks/useRefetchAll");
+var _useRefetchErrored = require("./hooks/useRefetchErrored");
+var _factory = require("./impl/infinite/factory");
+var _utils = require("./impl/infinite/utils");
+var _factory2 = require("./impl/plain/factory");
+var _utils2 = require("./impl/plain/utils");
+var _normalizeStatus = require("./utils/normalizeStatus");
+var _ClientDataManager = require("./ClientDataManager");
+// #sourceMappingURL=index.js.map

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

@@ -0,0 +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":[]}

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.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/utils/normalizeStatus.d.ts

@@ -0,0 +1,3 @@
+import type { FetchStatus, QueryStatus } from '@tanstack/react-query';
+import type { DataLoaderStatus } from '../../core';
+export declare const normalizeStatus: (status: QueryStatus, fetchStatus: FetchStatus) => DataLoaderStatus;

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

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeStatus = void 0;
+var normalizeStatus = exports.normalizeStatus = function normalizeStatus(status, fetchStatus) {
+  if (status === 'loading' && fetchStatus === 'idle') {
+    return 'success';
+  }
+  return status;
+};
+// #sourceMappingURL=normalizeStatus.js.map

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

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

package/build/esm/core/constants.d.ts

@@ -0,0 +1 @@
+export declare const idle: unique symbol;

package/build/esm/core/constants.js

@@ -0,0 +1,2 @@
+export var idle = Symbol('idle');
+// #sourceMappingURL=constants.js.map

package/build/esm/core/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["idle","Symbol"],"sources":["constants.ts"],"sourcesContent":["export const idle = Symbol('idle');\n"],"mappings":"AAAA,OAAO,IAAMA,IAAI,GAAGC,MAAM,CAAC,MAAM,CAAC","ignoreList":[]}

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

@@ -0,0 +1,13 @@
+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 { idle } from './constants';
+export { composeKey } from './utils/composeKey';
+export { composeFullKey } from './utils/composeFullKey';
+export { getError } from './utils/getError';
+export { getStatus } from './utils/getStatus';
+export { hasTag } from './utils/hasTag';
+export { mergeStatuses } from './utils/mergeStatuses';
+export { skipContext } from './utils/skipContext';
+export type { Cancellable } from './utils/withCancellation';
+export { isCancellable, isAbortable, withCancellation } from './utils/withCancellation';

package/build/esm/core/index.js

@@ -0,0 +1,10 @@
+export { idle } from './constants';
+export { composeKey } from './utils/composeKey';
+export { composeFullKey } from './utils/composeFullKey';
+export { getError } from './utils/getError';
+export { getStatus } from './utils/getStatus';
+export { hasTag } from './utils/hasTag';
+export { mergeStatuses } from './utils/mergeStatuses';
+export { skipContext } from './utils/skipContext';
+export { isCancellable, isAbortable, withCancellation } from './utils/withCancellation';
+// #sourceMappingURL=index.js.map

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1 @@
+export type DataLoaderStatus = 'loading' | 'success' | 'error';

package/build/esm/core/types/DataLoaderStatus.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["DataLoaderStatus.ts"],"sourcesContent":["export type DataLoaderStatus = 'loading' | 'success' | 'error';\n"],"mappings":"","ignoreList":[]}

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

@@ -0,0 +1,10 @@
+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>;
+    resetSource<TDataSource extends AnyDataSource>(dataSource: TDataSource): Promise<void>;
+    invalidateParams<TDataSource extends AnyDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>): Promise<void>;
+    resetParams<TDataSource extends AnyDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>): Promise<void>;
+    invalidateSourceTags<TDataSource extends AnyDataSource>(dataSource: TDataSource, params: DataSourceParams<TDataSource>): Promise<void>;
+}

package/build/esm/core/types/DataManger.js

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

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1,28 @@
+import type { idle } from '../constants';
+export type DataSourceKey = readonly unknown[];
+export type DataSourceTag = string;
+declare const errorHintSymbol: unique symbol;
+declare const stateHintSymbol: unique symbol;
+export interface DataSource<TContext, TParams, TRequest, TResponse, TData, TError, TOptions, TState, TFetchContext> {
+    readonly name: string;
+    fetch: (context: TContext, fetchContext: TFetchContext, request: TRequest) => Promise<TResponse> | TResponse;
+    tags?: (params: ActualParams<this, TParams, TRequest>) => DataSourceTag[];
+    transformParams?: (params: TParams) => TRequest;
+    transformResponse?: (response: TResponse) => TData;
+    [errorHintSymbol]?: TError;
+    options?: TOptions;
+    [stateHintSymbol]?: TState;
+}
+export type AnyDataSource = DataSource<any, any, any, any, any, any, any, any, any>;
+export type DataSourceContext<TDataSource> = TDataSource extends DataSource<infer TContext, infer _TParams, infer _TRequest, infer _TResponse, infer _TData, infer _TError, infer _TOptions, infer _TState, infer _TFetchContext> ? TContext : never;
+export type DataSourceParams<TDataSource> = TDataSource extends DataSource<infer _TContenxt, infer TParams, infer TRequest, infer _TResponse, infer _TData, infer _TError, infer _TOptions, infer _TState, infer _TFetchContext> ? ActualParams<TDataSource, TParams, TRequest> : never;
+export type DataSourceRequest<TDataSource> = TDataSource extends DataSource<infer _TContenxt, infer _TParams, infer TRequest, infer _TResponse, infer _TData, infer _TError, infer _TOptions, infer _TState, infer _TFetchContext> ? TRequest : never;
+export type DataSourceResponse<TDataSource> = TDataSource extends DataSource<infer _TContenxt, infer _TParams, infer _TRequest, infer TResponse, infer _TData, infer _TError, infer _TOptions, infer _TState, infer _TFetchContext> ? TResponse : never;
+export type DataSourceData<TDataSource> = TDataSource extends DataSource<infer _TContenxt, infer _TParams, infer _TRequest, infer TResponse, infer TData, infer _TError, infer _TOptions, infer _TState, infer _TFetchContext> ? ActualData<TData, TResponse> : never;
+export type DataSourceError<TDataSource> = TDataSource extends DataSource<infer _TContenxt, infer _TParams, infer _TRequest, infer _TResponse, infer _TData, infer TError, infer _TOptions, infer _TState, infer _TFetchContext> ? TError : never;
+export type DataSourceOptions<TDataSource> = TDataSource extends DataSource<infer _TContenxt, infer _TParams, infer _TRequest, infer _TResponse, infer _TData, infer _TError, infer TOptions, infer _TState, infer _TFetchContext> ? TOptions : never;
+export type DataSourceState<TDataSource> = TDataSource extends DataSource<infer _TContenxt, infer _TParams, infer _TRequest, infer _TResponse, infer _TData, infer _TError, infer _TOptions, infer TState, infer _TFetchContext> ? TState : never;
+export type DataSourceFetchContext<TDataSource> = TDataSource extends DataSource<infer _TContenxt, infer _TParams, infer _TRequest, infer _TResponse, infer _TData, infer _TError, infer _TOptions, infer _TState, infer TFetchContext> ? TFetchContext : never;
+export type ActualParams<TDataSource extends AnyDataSource, TParams, TRequest> = (unknown extends TParams ? TRequest : undefined extends TDataSource['transformParams'] ? TRequest : TParams) | typeof idle;
+export type ActualData<TData, TResponse> = unknown extends TData ? TResponse : TData;
+export {};

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

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