@gravity-ui/data-source 0.1.0

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

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

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

@@ -0,0 +1,2 @@
+import type { QueryDataSourceContext } from '../types';
+export declare const useQueryContext: () => QueryDataSourceContext;

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

@@ -0,0 +1,12 @@
+import { useMemo } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+export var useQueryContext = function useQueryContext() {
+  var queryClient = useQueryClient();
+  var queryContext = useMemo(function () {
+    return {
+      queryClient: queryClient
+    };
+  }, [queryClient]);
+  return queryContext;
+};
+// #sourceMappingURL=useQueryContext.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useMemo","useQueryClient","useQueryContext","queryClient","queryContext"],"sources":["useQueryContext.ts"],"sourcesContent":["import {useMemo} from 'react';\n\nimport {useQueryClient} from '@tanstack/react-query';\n\nimport type {QueryDataSourceContext} from '../types';\n\nexport const useQueryContext = (): QueryDataSourceContext => {\n    const queryClient = useQueryClient();\n    const queryContext = useMemo(() => ({queryClient}), [queryClient]);\n\n    return queryContext;\n};\n"],"mappings":"AAAA,SAAQA,OAAO,QAAO,OAAO;AAE7B,SAAQC,cAAc,QAAO,uBAAuB;AAIpD,OAAO,IAAMC,eAAe,GAAG,SAAlBA,eAAeA,CAAA,EAAiC;EACzD,IAAMC,WAAW,GAAGF,cAAc,CAAC,CAAC;EACpC,IAAMG,YAAY,GAAGJ,OAAO,CAAC;IAAA,OAAO;MAACG,WAAW,EAAXA;IAAW,CAAC;EAAA,CAAC,EAAE,CAACA,WAAW,CAAC,CAAC;EAElE,OAAOC,YAAY;AACvB,CAAC","ignoreList":[]}

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

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

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

@@ -0,0 +1,20 @@
+import { useInfiniteQueryData } from '../impl/infinite/hooks';
+import { usePlainQueryData } from '../impl/plain/hooks';
+import { useQueryContext } from './useQueryContext';
+export var useQueryData = function useQueryData(dataSource, params, options) {
+  var context = useQueryContext();
+  var state;
+
+  // Do not change data source type in the same hook call
+  if (dataSource.type === 'plain') {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    state = usePlainQueryData(context, dataSource, params, options);
+  } else if (dataSource.type === 'infinite') {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    state = useInfiniteQueryData(context, dataSource, params, options);
+  } else {
+    throw new Error('Data Source type must be plain or infinite');
+  }
+  return state;
+};
+// #sourceMappingURL=useQueryData.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useInfiniteQueryData","usePlainQueryData","useQueryContext","useQueryData","dataSource","params","options","context","state","type","Error"],"sources":["useQueryData.ts"],"sourcesContent":["import type {DataSourceOptions, DataSourceParams, DataSourceState} from '../../core';\nimport {useInfiniteQueryData} from '../impl/infinite/hooks';\nimport {usePlainQueryData} from '../impl/plain/hooks';\nimport type {AnyQueryDataSource} from '../types';\n\nimport {useQueryContext} from './useQueryContext';\n\nexport const useQueryData = <TDataSource extends AnyQueryDataSource>(\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: DataSourceOptions<TDataSource>,\n): DataSourceState<TDataSource> => {\n    const context = useQueryContext();\n\n    let state: DataSourceState<AnyQueryDataSource> | undefined;\n\n    // Do not change data source type in the same hook call\n    if (dataSource.type === 'plain') {\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        state = usePlainQueryData(context, dataSource, params, options);\n    } else if (dataSource.type === 'infinite') {\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        state = useInfiniteQueryData(context, dataSource, params, options);\n    } else {\n        throw new Error('Data Source type must be plain or infinite');\n    }\n\n    return state as DataSourceState<TDataSource>;\n};\n"],"mappings":"AACA,SAAQA,oBAAoB,QAAO,wBAAwB;AAC3D,SAAQC,iBAAiB,QAAO,qBAAqB;AAGrD,SAAQC,eAAe,QAAO,mBAAmB;AAEjD,OAAO,IAAMC,YAAY,GAAG,SAAfA,YAAYA,CACrBC,UAAuB,EACvBC,MAAqC,EACrCC,OAAwC,EACT;EAC/B,IAAMC,OAAO,GAAGL,eAAe,CAAC,CAAC;EAEjC,IAAIM,KAAsD;;EAE1D;EACA,IAAIJ,UAAU,CAACK,IAAI,KAAK,OAAO,EAAE;IAC7B;IACAD,KAAK,GAAGP,iBAAiB,CAACM,OAAO,EAAEH,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EACnE,CAAC,MAAM,IAAIF,UAAU,CAACK,IAAI,KAAK,UAAU,EAAE;IACvC;IACAD,KAAK,GAAGR,oBAAoB,CAACO,OAAO,EAAEH,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EACtE,CAAC,MAAM;IACH,MAAM,IAAII,KAAK,CAAC,4CAA4C,CAAC;EACjE;EAEA,OAAOF,KAAK;AAChB,CAAC","ignoreList":[]}

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

@@ -0,0 +1,11 @@
+import type { DataLoaderStatus } from '../../core';
+export declare const useQueryResponses: <TError>(responses: {
+    status: DataLoaderStatus;
+    error: TError | null;
+    refetch: Function;
+}[]) => {
+    status: DataLoaderStatus;
+    error: NonNullable<TError> | null;
+    refetch: () => void;
+    refetchErrored: () => void;
+};

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

@@ -0,0 +1,12 @@
+import { getError, getStatus } from '../../core';
+import { useRefetchAll } from './useRefetchAll';
+import { useRefetchErrored } from './useRefetchErrored';
+export var useQueryResponses = function useQueryResponses(responses) {
+  return {
+    status: getStatus(responses),
+    error: getError(responses),
+    refetch: useRefetchAll(responses),
+    refetchErrored: useRefetchErrored(responses)
+  };
+};
+// #sourceMappingURL=useQueryResponses.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["getError","getStatus","useRefetchAll","useRefetchErrored","useQueryResponses","responses","status","error","refetch","refetchErrored"],"sources":["useQueryResponses.ts"],"sourcesContent":["import type {DataLoaderStatus} from '../../core';\nimport {getError, getStatus} from '../../core';\n\nimport {useRefetchAll} from './useRefetchAll';\nimport {useRefetchErrored} from './useRefetchErrored';\n\nexport const useQueryResponses = <TError>(\n    responses: {\n        status: DataLoaderStatus;\n        error: TError | null;\n        refetch: Function;\n    }[],\n) => {\n    return {\n        status: getStatus(responses),\n        error: getError(responses),\n        refetch: useRefetchAll(responses),\n        refetchErrored: useRefetchErrored(responses),\n    };\n};\n"],"mappings":"AACA,SAAQA,QAAQ,EAAEC,SAAS,QAAO,YAAY;AAE9C,SAAQC,aAAa,QAAO,iBAAiB;AAC7C,SAAQC,iBAAiB,QAAO,qBAAqB;AAErD,OAAO,IAAMC,iBAAiB,GAAG,SAApBA,iBAAiBA,CAC1BC,SAIG,EACF;EACD,OAAO;IACHC,MAAM,EAAEL,SAAS,CAACI,SAAS,CAAC;IAC5BE,KAAK,EAAEP,QAAQ,CAACK,SAAS,CAAC;IAC1BG,OAAO,EAAEN,aAAa,CAACG,SAAS,CAAC;IACjCI,cAAc,EAAEN,iBAAiB,CAACE,SAAS;EAC/C,CAAC;AACL,CAAC","ignoreList":[]}

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

@@ -0,0 +1,3 @@
+export declare const useRefetchAll: (states: {
+    refetch: Function;
+}[]) => () => void;

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

@@ -0,0 +1,15 @@
+import { useCallback } from 'react';
+export var useRefetchAll = function useRefetchAll(states) {
+  return useCallback(function () {
+    return states.forEach(function (_ref) {
+      var refetch = _ref.refetch;
+      return refetch();
+    });
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  states.map(function (_ref2) {
+    var refetch = _ref2.refetch;
+    return refetch;
+  }));
+};
+// #sourceMappingURL=useRefetchAll.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useCallback","useRefetchAll","states","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,SAAQA,WAAW,QAAO,OAAO;AAEjC,OAAO,IAAMC,aAAa,GAAG,SAAhBA,aAAaA,CAAIC,MAA6B,EAAK;EAC5D,OAAOF,WAAW,CACd;IAAA,OAAME,MAAM,CAACC,OAAO,CAAC,UAAAC,IAAA;MAAA,IAAEC,OAAO,GAAAD,IAAA,CAAPC,OAAO;MAAA,OAAMA,OAAO,CAAC,CAAC;IAAA,EAAC;EAAA;EAC9C;EACAH,MAAM,CAACI,GAAG,CAAC,UAAAC,KAAA;IAAA,IAAEF,OAAO,GAAAE,KAAA,CAAPF,OAAO;IAAA,OAAMA,OAAO;EAAA,EACrC,CAAC;AACL,CAAC","ignoreList":[]}

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

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

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

@@ -0,0 +1,18 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { useCallback } from 'react';
+export var useRefetchErrored = function useRefetchErrored(states) {
+  return 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(_toConsumableArray(acc), [error, refetch]);
+  }, []));
+};
+// #sourceMappingURL=useRefetchErrored.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useCallback","useRefetchErrored","states","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,SAAQA,WAAW,QAAO,OAAO;AAEjC,OAAO,IAAMC,iBAAiB,GAAG,SAApBA,iBAAiBA,CAAYC,MAAmD,EAAK;EAC9F,OAAOF,WAAW,CACd;IAAA,OAAME,MAAM,CAACC,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;EACAJ,MAAM,CAACK,MAAM,CAAiB,UAACC,GAAG,EAAAC,KAAA;IAAA,IAAGJ,KAAK,GAAAI,KAAA,CAALJ,KAAK;MAAEC,OAAO,GAAAG,KAAA,CAAPH,OAAO;IAAA,UAAAI,MAAA,CAAAC,kBAAA,CAAUH,GAAG,IAAEH,KAAK,EAAEC,OAAO;EAAA,CAAC,EAAE,EAAE,CACzF,CAAC;AACL,CAAC","ignoreList":[]}

package/build/esm/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/esm/react-query/impl/infinite/factory.js

@@ -0,0 +1,7 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+export var makeInfiniteQueryDataSource = function makeInfiniteQueryDataSource(config) {
+  return _objectSpread(_objectSpread({}, config), {}, {
+    type: 'infinite'
+  });
+};
+// #sourceMappingURL=factory.js.map

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

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

package/build/esm/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/esm/react-query/impl/infinite/hooks.js

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

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

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

package/build/esm/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/esm/react-query/impl/infinite/types.js

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

package/build/esm/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/esm/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/esm/react-query/impl/infinite/utils.js

@@ -0,0 +1,42 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import { composeFullKey, idle } from '../../../core';
+import { normalizeStatus } from '../../utils/normalizeStatus';
+var EMPTY_ARRAY = [];
+export var composeOptions = function composeOptions(context, dataSource, params, options) {
+  var transformParams = dataSource.transformParams,
+    transformResponse = dataSource.transformResponse,
+    next = dataSource.next,
+    prev = dataSource.prev;
+  return _objectSpread(_objectSpread({}, dataSource.options), {}, {
+    enabled: params !== idle,
+    queryKey: 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 _objectSpread(_objectSpread({}, data), {}, {
+        pages: data.pages.map(transformResponse)
+      });
+    } : undefined,
+    getNextPageParam: function getNextPageParam(lastPage, allPages) {
+      var nextParamsPatch = next(lastPage, allPages);
+      return nextParamsPatch ? _objectSpread(_objectSpread({}, params), nextParamsPatch) : undefined;
+    },
+    getPreviousPageParam: prev ? function (firstPage, allPages) {
+      var prevParamsPatch = prev(firstPage, allPages);
+      return prevParamsPatch ? _objectSpread(_objectSpread({}, params), prevParamsPatch) : undefined;
+    } : undefined
+  }, options);
+};
+export var transformResult = function transformResult(result) {
+  var _result$data$pages$fl, _result$data;
+  return _objectSpread(_objectSpread({}, result), {}, {
+    status: normalizeStatus(result.status, result.fetchStatus),
+    data: (_result$data$pages$fl = (_result$data = result.data) === null || _result$data === void 0 ? void 0 : _result$data.pages.flat()) !== null && _result$data$pages$fl !== void 0 ? _result$data$pages$fl : EMPTY_ARRAY,
+    originalStatus: result.status,
+    originalData: result.data
+  });
+};
+// #sourceMappingURL=utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["composeFullKey","idle","normalizeStatus","EMPTY_ARRAY","composeOptions","context","dataSource","params","options","transformParams","transformResponse","next","prev","_objectSpread","enabled","queryKey","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","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,SASIA,cAAc,EACdC,IAAI,QACD,eAAe;AACtB,SAAQC,eAAe,QAAO,6BAA6B;AAI3D,IAAMC,WAAsB,GAAG,EAAE;AAEjC,OAAO,IAAMC,cAAc,GAAG,SAAjBA,cAAcA,CACvBC,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAwC,EAMvC;EACD,IAAOC,eAAe,GAAmCH,UAAU,CAA5DG,eAAe;IAAEC,iBAAiB,GAAgBJ,UAAU,CAA3CI,iBAAiB;IAAEC,IAAI,GAAUL,UAAU,CAAxBK,IAAI;IAAEC,IAAI,GAAIN,UAAU,CAAlBM,IAAI;EAErD,OAAAC,aAAA,CAAAA,aAAA,KACOP,UAAU,CAACE,OAAO;IACrBM,OAAO,EAAEP,MAAM,KAAKN,IAAI;IACxBc,QAAQ,EAAEf,cAAc,CAACM,UAAU,EAAEC,MAAM,CAAC;IAC5CS,OAAO,EAAE,SAATA,OAAOA,CACHC,YAAgF,EAC/E;MAAA,IAAAC,qBAAA;MACD,IAAMC,YAAY,IAAAD,qBAAA,GAAGD,YAAY,CAACG,SAAS,cAAAF,qBAAA,cAAAA,qBAAA,GAAIX,MAAM;MAErD,OAAOD,UAAU,CAACe,KAAK,CACnBhB,OAAO,EACPY,YAAY,EACZR,eAAe,GAAGA,eAAe,CAACU,YAAY,CAAC,GAAGA,YACtD,CAAC;IACL,CAAC;IACDG,MAAM,EAAEZ,iBAAiB,GACnB,UAACa,IAAI;MAAA,OAAAV,aAAA,CAAAA,aAAA,KAAUU,IAAI;QAAEC,KAAK,EAAED,IAAI,CAACC,KAAK,CAACC,GAAG,CAACf,iBAAiB;MAAC;IAAA,CAAE,GAC/DgB,SAAS;IACfC,gBAAgB,EAAE,SAAlBA,gBAAgBA,CAAGC,QAAQ,EAAEC,QAAQ,EAAK;MACtC,IAAMC,eAAe,GAAGnB,IAAI,CAACiB,QAAQ,EAAEC,QAAQ,CAAC;MAEhD,OAAOC,eAAe,GAAAjB,aAAA,CAAAA,aAAA,KAAON,MAAM,GAAKuB,eAAe,IAAIJ,SAAS;IACxE,CAAC;IACDK,oBAAoB,EAAEnB,IAAI,GACpB,UAACoB,SAAS,EAAEH,QAAQ,EAAK;MACrB,IAAMI,eAAe,GAAGrB,IAAI,CAACoB,SAAS,EAAEH,QAAQ,CAAC;MAEjD,OAAOI,eAAe,GAAApB,aAAA,CAAAA,aAAA,KAAON,MAAM,GAAK0B,eAAe,IAAIP,SAAS;IACxE,CAAC,GACDA;EAAS,GACZlB,OAAO;AAElB,CAAC;AAED,OAAO,IAAM0B,eAAe,GAAG,SAAlBA,eAAeA,CACxBC,MAA8F,EAC7F;EAAA,IAAAC,qBAAA,EAAAC,YAAA;EACD,OAAAxB,aAAA,CAAAA,aAAA,KACOsB,MAAM;IACTG,MAAM,EAAEpC,eAAe,CAACiC,MAAM,CAACG,MAAM,EAAEH,MAAM,CAACI,WAAW,CAAC;IAC1DhB,IAAI,GAAAa,qBAAA,IAAAC,YAAA,GAAEF,MAAM,CAACZ,IAAI,cAAAc,YAAA,uBAAXA,YAAA,CAAab,KAAK,CAACgB,IAAI,CAAC,CAAC,cAAAJ,qBAAA,cAAAA,qBAAA,GAAIjC,WAAW;IAC9CsC,cAAc,EAAEN,MAAM,CAACG,MAAM;IAC7BI,YAAY,EAAEP,MAAM,CAACZ;EAAI;AAEjC,CAAC","ignoreList":[]}

package/build/esm/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/esm/react-query/impl/plain/factory.js

@@ -0,0 +1,7 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+export var makePlainQueryDataSource = function makePlainQueryDataSource(config) {
+  return _objectSpread(_objectSpread({}, config), {}, {
+    type: 'plain'
+  });
+};
+// #sourceMappingURL=factory.js.map

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

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

package/build/esm/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/esm/react-query/impl/plain/hooks.js

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

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

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

package/build/esm/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/esm/react-query/impl/plain/types.js

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

package/build/esm/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/esm/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/esm/react-query/impl/plain/utils.js

@@ -0,0 +1,21 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import { composeFullKey, idle } from '../../../core';
+import { normalizeStatus } from '../../utils/normalizeStatus';
+export var composeOptions = function composeOptions(context, dataSource, params, options) {
+  var transformParams = dataSource.transformParams;
+  return _objectSpread(_objectSpread({}, dataSource.options), {}, {
+    enabled: params !== idle,
+    queryKey: composeFullKey(dataSource, params),
+    queryFn: function queryFn(fetchContext) {
+      return dataSource.fetch(context, fetchContext, transformParams ? transformParams(params) : params);
+    },
+    select: dataSource.transformResponse
+  }, options);
+};
+export var transformResult = function transformResult(result) {
+  return _objectSpread(_objectSpread({}, result), {}, {
+    status: normalizeStatus(result.status, result.fetchStatus),
+    originalStatus: result.status
+  });
+};
+// #sourceMappingURL=utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["composeFullKey","idle","normalizeStatus","composeOptions","context","dataSource","params","options","transformParams","_objectSpread","enabled","queryKey","queryFn","fetchContext","fetch","select","transformResponse","transformResult","result","status","fetchStatus","originalStatus"],"sources":["utils.ts"],"sourcesContent":["import type {\n    QueryFunctionContext,\n    QueryObserverOptions,\n    QueryObserverResult,\n} from '@tanstack/react-query';\n\nimport {composeFullKey, idle} from '../../../core';\nimport type {\n    DataSourceContext,\n    DataSourceData,\n    DataSourceError,\n    DataSourceKey,\n    DataSourceOptions,\n    DataSourceParams,\n    DataSourceResponse,\n    DataSourceState,\n} from '../../../core';\nimport {normalizeStatus} from '../../utils/normalizeStatus';\n\nimport type {AnyPlainQueryDataSource} from './types';\n\nexport const composeOptions = <TDataSource extends AnyPlainQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: DataSourceOptions<TDataSource>,\n): QueryObserverOptions<\n    DataSourceResponse<TDataSource>,\n    DataSourceError<TDataSource>,\n    DataSourceData<TDataSource>,\n    DataSourceResponse<TDataSource>\n> => {\n    const {transformParams} = dataSource;\n\n    return {\n        ...dataSource.options,\n        enabled: params !== idle,\n        queryKey: composeFullKey(dataSource, params),\n        queryFn: (fetchContext: QueryFunctionContext<DataSourceKey, unknown>) =>\n            dataSource.fetch(\n                context,\n                fetchContext,\n                transformParams ? transformParams(params) : params,\n            ),\n        select: dataSource.transformResponse,\n        ...options,\n    };\n};\n\nexport const transformResult = <TDataSource extends AnyPlainQueryDataSource>(\n    result: QueryObserverResult<DataSourceData<TDataSource>, DataSourceError<TDataSource>>,\n) => {\n    return {\n        ...result,\n        status: normalizeStatus(result.status, result.fetchStatus),\n        originalStatus: result.status,\n    } as DataSourceState<TDataSource>;\n};\n"],"mappings":";AAMA,SAAQA,cAAc,EAAEC,IAAI,QAAO,eAAe;AAWlD,SAAQC,eAAe,QAAO,6BAA6B;AAI3D,OAAO,IAAMC,cAAc,GAAG,SAAjBA,cAAcA,CACvBC,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAwC,EAMvC;EACD,IAAOC,eAAe,GAAIH,UAAU,CAA7BG,eAAe;EAEtB,OAAAC,aAAA,CAAAA,aAAA,KACOJ,UAAU,CAACE,OAAO;IACrBG,OAAO,EAAEJ,MAAM,KAAKL,IAAI;IACxBU,QAAQ,EAAEX,cAAc,CAACK,UAAU,EAAEC,MAAM,CAAC;IAC5CM,OAAO,EAAE,SAATA,OAAOA,CAAGC,YAA0D;MAAA,OAChER,UAAU,CAACS,KAAK,CACZV,OAAO,EACPS,YAAY,EACZL,eAAe,GAAGA,eAAe,CAACF,MAAM,CAAC,GAAGA,MAChD,CAAC;IAAA;IACLS,MAAM,EAAEV,UAAU,CAACW;EAAiB,GACjCT,OAAO;AAElB,CAAC;AAED,OAAO,IAAMU,eAAe,GAAG,SAAlBA,eAAeA,CACxBC,MAAsF,EACrF;EACD,OAAAT,aAAA,CAAAA,aAAA,KACOS,MAAM;IACTC,MAAM,EAAEjB,eAAe,CAACgB,MAAM,CAACC,MAAM,EAAED,MAAM,CAACE,WAAW,CAAC;IAC1DC,cAAc,EAAEH,MAAM,CAACC;EAAM;AAErC,CAAC","ignoreList":[]}

package/build/esm/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/esm/react-query/index.js

@@ -0,0 +1,12 @@
+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 { makeInfiniteQueryDataSource } from './impl/infinite/factory';
+export { composeOptions as composeInfiniteQueryOptions } from './impl/infinite/utils';
+export { makePlainQueryDataSource } from './impl/plain/factory';
+export { composeOptions as composePlainQueryOptions } from './impl/plain/utils';
+export { normalizeStatus } from './utils/normalizeStatus';
+export { ClientDataManager } from './ClientDataManager';
+// #sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useQueryContext","useQueryData","useQueryResponses","useRefetchAll","useRefetchErrored","makeInfiniteQueryDataSource","composeOptions","composeInfiniteQueryOptions","makePlainQueryDataSource","composePlainQueryOptions","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,SAAQA,eAAe,QAAO,yBAAyB;AACvD,SAAQC,YAAY,QAAO,sBAAsB;AACjD,SAAQC,iBAAiB,QAAO,2BAA2B;AAC3D,SAAQC,aAAa,QAAO,uBAAuB;AACnD,SAAQC,iBAAiB,QAAO,2BAA2B;AAG3D,SAAQC,2BAA2B,QAAO,yBAAyB;AACnE,SAAQC,cAAc,IAAIC,2BAA2B,QAAO,uBAAuB;AAGnF,SAAQC,wBAAwB,QAAO,sBAAsB;AAC7D,SAAQF,cAAc,IAAIG,wBAAwB,QAAO,oBAAoB;AAE7E,SAAQC,eAAe,QAAO,yBAAyB;AAGvD,SAAQC,iBAAiB,QAAO,qBAAqB","ignoreList":[]}

package/build/esm/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/esm/react-query/types.js

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

package/build/esm/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/esm/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/esm/react-query/utils/normalizeStatus.js

@@ -0,0 +1,7 @@
+export var normalizeStatus = function normalizeStatus(status, fetchStatus) {
+  if (status === 'loading' && fetchStatus === 'idle') {
+    return 'success';
+  }
+  return status;
+};
+// #sourceMappingURL=normalizeStatus.js.map

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

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

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@gravity-ui/data-source",
+  "version": "0.1.0",
+  "description": "A wrapper around data fetching",
+  "keywords": [
+    "data-fetching",
+    "react",
+    "react-query",
+    "gravity-ui"
+  ],
+  "author": "Mikhail Golbakh <golbah@yandex.ru>",
+  "license": "MIT",
+  "homepage": "https://github.com/gravity-ui/data-source#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gravity-ui/data-source.git"
+  },
+  "bugs": {
+    "url": "https://github.com/gravity-ui/data-source/issues"
+  },
+  "engines": {
+    "node": ">= 18",
+    "npm": ">= 9",
+    "yarn": "Please use npm instead of yarn to install dependencies",
+    "pnpm": "Please use npm instead of pnpm to install dependencies"
+  },
+  "main": "build/cjs/index.js",
+  "module": "build/esm/index.js",
+  "types": "build/esm/index.d.ts",
+  "files": [
+    "build"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "NODE_ENV=production app-builder build",
+    "clean": "rm -rf build",
+    "deps:ci": "npm ci",
+    "lint": "eslint .",
+    "lint:fix": "npm run lint -- --fix",
+    "prepare": "husky install",
+    "prepublishOnly": "npm run build",
+    "test": "jest --passWithNoTests",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.3.0",
+    "@commitlint/config-conventional": "^19.2.2",
+    "@gravity-ui/app-builder": "^0.11.1",
+    "@gravity-ui/eslint-config": "^3.2.0",
+    "@gravity-ui/prettier-config": "^1.1.0",
+    "@gravity-ui/tsconfig": "^1.0.0",
+    "@swc/jest": "^0.2.36",
+    "@tanstack/react-query": "^4.36.1",
+    "@types/jest": "^29.5.12",
+    "@types/react": "^18.3.3",
+    "eslint": "^8.57.0",
+    "husky": "^9.0.11",
+    "jest": "^29.7.0",
+    "nano-staged": "^0.8.0",
+    "react": "^18.3.1",
+    "utility-types": "^3.11.0"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": "^4.0.0",
+    "react": "^16.0.0 || ^17.0.0 || ^18.0.0"
+  }
+}