@gravity-ui/data-source 0.7.0 → 0.8.0

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

@@ -1,9 +1,10 @@
 import _objectSpread from "@babel/runtime/helpers/objectSpread2";
 import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
 var _excluded = ["queryFn", "refetchInterval"];
-import { useQuery } from '@tanstack/react-query';
+import { skipToken, useQuery } from '@tanstack/react-query';
 import { useRefetchInterval } from '../../hooks/useRefetchInterval';
 import { normalizeStatus } from '../../utils/normalizeStatus';
+import { warnDisabledRefetch } from '../../utils/warnDisabledRefetch';
 import { composeOptions } from './utils';
 var usePlainQueryDataOptions = function usePlainQueryDataOptions(composedOptions) {
   var queryFnOption = composedOptions.queryFn,
@@ -21,9 +22,11 @@ export var usePlainQueryData = function usePlainQueryData(context, dataSource, p
   var extendedOptions = composeOptions(context, dataSource, params, options);
   var composedOptions = usePlainQueryDataOptions(extendedOptions);
   var state = useQuery(composedOptions);
+  var isDisabled = composedOptions.enabled === false || composedOptions.queryFn === skipToken;
   return _objectSpread(_objectSpread({}, state), {}, {
     status: normalizeStatus(state.status, state.fetchStatus),
-    originalStatus: state.status
+    originalStatus: state.status,
+    refetch: isDisabled ? warnDisabledRefetch : state.refetch
   });
 };
 // #sourceMappingURL=hooks.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["useQuery","useRefetchInterval","normalizeStatus","composeOptions","usePlainQueryDataOptions","composedOptions","queryFnOption","queryFn","refetchIntervalOption","refetchInterval","restOptions","_objectWithoutProperties","_excluded","_useRefetchInterval","_objectSpread","usePlainQueryData","context","dataSource","params","options","extendedOptions","state","status","fetchStatus","originalStatus"],"sources":["hooks.ts"],"sourcesContent":["import {type QueryObserverOptions, useQuery} from '@tanstack/react-query';\n\nimport type {\n    DataSourceContext,\n    DataSourceData,\n    DataSourceError,\n    DataSourceKey,\n    DataSourceOptions,\n    DataSourceParams,\n    DataSourceResponse,\n    DataSourceState,\n} from '../../../core';\nimport {useRefetchInterval} from '../../hooks/useRefetchInterval';\nimport {normalizeStatus} from '../../utils/normalizeStatus';\n\nimport type {AnyPlainQueryDataSource, QueryObserverExtendedOptions} from './types';\nimport {composeOptions} from './utils';\n\nconst usePlainQueryDataOptions = <TDataSource extends AnyPlainQueryDataSource>(\n    composedOptions: QueryObserverExtendedOptions<\n        DataSourceResponse<TDataSource>,\n        DataSourceError<TDataSource>,\n        DataSourceData<TDataSource>,\n        DataSourceResponse<TDataSource>,\n        DataSourceKey\n    >,\n): QueryObserverOptions<\n    DataSourceResponse<TDataSource>,\n    DataSourceError<TDataSource>,\n    DataSourceData<TDataSource>,\n    DataSourceResponse<TDataSource>,\n    DataSourceKey\n> => {\n    const {\n        queryFn: queryFnOption,\n        refetchInterval: refetchIntervalOption,\n        ...restOptions\n    } = composedOptions;\n\n    const {queryFn, refetchInterval} = useRefetchInterval(refetchIntervalOption, queryFnOption);\n\n    return {...restOptions, queryFn, refetchInterval};\n};\n\nexport const usePlainQueryData = <TDataSource extends AnyPlainQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: Partial<DataSourceOptions<TDataSource>>,\n): DataSourceState<TDataSource> => {\n    const extendedOptions = composeOptions(context, dataSource, params, options);\n    const composedOptions = usePlainQueryDataOptions(extendedOptions);\n    const state = useQuery(composedOptions);\n\n    return {\n        ...state,\n        status: normalizeStatus(state.status, state.fetchStatus),\n        originalStatus: state.status,\n    } as DataSourceState<TDataSource>;\n};\n"],"mappings":";;;AAAA,SAAmCA,QAAQ,QAAO,uBAAuB;AAYzE,SAAQC,kBAAkB,QAAO,gCAAgC;AACjE,SAAQC,eAAe,QAAO,6BAA6B;AAG3D,SAAQC,cAAc,QAAO,SAAS;AAEtC,IAAMC,wBAAwB,GAAG,SAA3BA,wBAAwBA,CAC1BC,eAMC,EAOA;EACD,IACaC,aAAa,GAGtBD,eAAe,CAHfE,OAAO;IACUC,qBAAqB,GAEtCH,eAAe,CAFfI,eAAe;IACZC,WAAW,GAAAC,wBAAA,CACdN,eAAe,EAAAO,SAAA;EAEnB,IAAAC,mBAAA,GAAmCZ,kBAAkB,CAACO,qBAAqB,EAAEF,aAAa,CAAC;IAApFC,OAAO,GAAAM,mBAAA,CAAPN,OAAO;IAAEE,eAAe,GAAAI,mBAAA,CAAfJ,eAAe;EAE/B,OAAAK,aAAA,CAAAA,aAAA,KAAWJ,WAAW;IAAEH,OAAO,EAAPA,OAAO;IAAEE,eAAe,EAAfA;EAAe;AACpD,CAAC;AAED,OAAO,IAAMM,iBAAiB,GAAG,SAApBA,iBAAiBA,CAC1BC,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAiD,EAClB;EAC/B,IAAMC,eAAe,GAAGjB,cAAc,CAACa,OAAO,EAAEC,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EAC5E,IAAMd,eAAe,GAAGD,wBAAwB,CAACgB,eAAe,CAAC;EACjE,IAAMC,KAAK,GAAGrB,QAAQ,CAACK,eAAe,CAAC;EAEvC,OAAAS,aAAA,CAAAA,aAAA,KACOO,KAAK;IACRC,MAAM,EAAEpB,eAAe,CAACmB,KAAK,CAACC,MAAM,EAAED,KAAK,CAACE,WAAW,CAAC;IACxDC,cAAc,EAAEH,KAAK,CAACC;EAAM;AAEpC,CAAC","ignoreList":[]}
+{"version":3,"names":["skipToken","useQuery","useRefetchInterval","normalizeStatus","warnDisabledRefetch","composeOptions","usePlainQueryDataOptions","composedOptions","queryFnOption","queryFn","refetchIntervalOption","refetchInterval","restOptions","_objectWithoutProperties","_excluded","_useRefetchInterval","_objectSpread","usePlainQueryData","context","dataSource","params","options","extendedOptions","state","isDisabled","enabled","status","fetchStatus","originalStatus","refetch"],"sources":["hooks.ts"],"sourcesContent":["import {type QueryObserverOptions, skipToken, useQuery} from '@tanstack/react-query';\n\nimport type {\n    DataSourceContext,\n    DataSourceData,\n    DataSourceError,\n    DataSourceKey,\n    DataSourceOptions,\n    DataSourceParams,\n    DataSourceResponse,\n    DataSourceState,\n} from '../../../core';\nimport {useRefetchInterval} from '../../hooks/useRefetchInterval';\nimport {normalizeStatus} from '../../utils/normalizeStatus';\nimport {warnDisabledRefetch} from '../../utils/warnDisabledRefetch';\n\nimport type {AnyPlainQueryDataSource, QueryObserverExtendedOptions} from './types';\nimport {composeOptions} from './utils';\n\nconst usePlainQueryDataOptions = <TDataSource extends AnyPlainQueryDataSource>(\n    composedOptions: QueryObserverExtendedOptions<\n        DataSourceResponse<TDataSource>,\n        DataSourceError<TDataSource>,\n        DataSourceData<TDataSource>,\n        DataSourceResponse<TDataSource>,\n        DataSourceKey\n    >,\n): QueryObserverOptions<\n    DataSourceResponse<TDataSource>,\n    DataSourceError<TDataSource>,\n    DataSourceData<TDataSource>,\n    DataSourceResponse<TDataSource>,\n    DataSourceKey\n> => {\n    const {\n        queryFn: queryFnOption,\n        refetchInterval: refetchIntervalOption,\n        ...restOptions\n    } = composedOptions;\n\n    const {queryFn, refetchInterval} = useRefetchInterval(refetchIntervalOption, queryFnOption);\n\n    return {...restOptions, queryFn, refetchInterval};\n};\n\nexport const usePlainQueryData = <TDataSource extends AnyPlainQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: Partial<DataSourceOptions<TDataSource>>,\n): DataSourceState<TDataSource> => {\n    const extendedOptions = composeOptions(context, dataSource, params, options);\n    const composedOptions = usePlainQueryDataOptions(extendedOptions);\n    const state = useQuery(composedOptions);\n\n    const isDisabled = composedOptions.enabled === false || composedOptions.queryFn === skipToken;\n\n    return {\n        ...state,\n        status: normalizeStatus(state.status, state.fetchStatus),\n        originalStatus: state.status,\n        refetch: isDisabled ? warnDisabledRefetch : state.refetch,\n    } as DataSourceState<TDataSource>;\n};\n"],"mappings":";;;AAAA,SAAmCA,SAAS,EAAEC,QAAQ,QAAO,uBAAuB;AAYpF,SAAQC,kBAAkB,QAAO,gCAAgC;AACjE,SAAQC,eAAe,QAAO,6BAA6B;AAC3D,SAAQC,mBAAmB,QAAO,iCAAiC;AAGnE,SAAQC,cAAc,QAAO,SAAS;AAEtC,IAAMC,wBAAwB,GAAG,SAA3BA,wBAAwBA,CAC1BC,eAMC,EAOA;EACD,IACaC,aAAa,GAGtBD,eAAe,CAHfE,OAAO;IACUC,qBAAqB,GAEtCH,eAAe,CAFfI,eAAe;IACZC,WAAW,GAAAC,wBAAA,CACdN,eAAe,EAAAO,SAAA;EAEnB,IAAAC,mBAAA,GAAmCb,kBAAkB,CAACQ,qBAAqB,EAAEF,aAAa,CAAC;IAApFC,OAAO,GAAAM,mBAAA,CAAPN,OAAO;IAAEE,eAAe,GAAAI,mBAAA,CAAfJ,eAAe;EAE/B,OAAAK,aAAA,CAAAA,aAAA,KAAWJ,WAAW;IAAEH,OAAO,EAAPA,OAAO;IAAEE,eAAe,EAAfA;EAAe;AACpD,CAAC;AAED,OAAO,IAAMM,iBAAiB,GAAG,SAApBA,iBAAiBA,CAC1BC,OAAuC,EACvCC,UAAuB,EACvBC,MAAqC,EACrCC,OAAiD,EAClB;EAC/B,IAAMC,eAAe,GAAGjB,cAAc,CAACa,OAAO,EAAEC,UAAU,EAAEC,MAAM,EAAEC,OAAO,CAAC;EAC5E,IAAMd,eAAe,GAAGD,wBAAwB,CAACgB,eAAe,CAAC;EACjE,IAAMC,KAAK,GAAGtB,QAAQ,CAACM,eAAe,CAAC;EAEvC,IAAMiB,UAAU,GAAGjB,eAAe,CAACkB,OAAO,KAAK,KAAK,IAAIlB,eAAe,CAACE,OAAO,KAAKT,SAAS;EAE7F,OAAAgB,aAAA,CAAAA,aAAA,KACOO,KAAK;IACRG,MAAM,EAAEvB,eAAe,CAACoB,KAAK,CAACG,MAAM,EAAEH,KAAK,CAACI,WAAW,CAAC;IACxDC,cAAc,EAAEL,KAAK,CAACG,MAAM;IAC5BG,OAAO,EAAEL,UAAU,GAAGpB,mBAAmB,GAAGmB,KAAK,CAACM;EAAO;AAEjE,CAAC","ignoreList":[]}

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

@@ -1,9 +1,9 @@
 import type { DefaultError, QueryFunctionContext, QueryKey, QueryObserverOptions, QueryObserverResult } from '@tanstack/react-query';
-import type { Overwrite } from 'utility-types';
+import type { Assign, Overwrite } from 'utility-types';
 import type { ActualData, DataLoaderStatus, DataSource, DataSourceKey } from '../../../core';
 import type { QueryDataSourceContext } from '../../types/base';
 import type { QueryDataAdditionalOptions } from '../../types/options';
-export type QueryObserverExtendedOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = Overwrite<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, QueryDataAdditionalOptions<TQueryFnData, TError, TQueryData, TQueryKey>>;
+export type QueryObserverExtendedOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = Assign<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, QueryDataAdditionalOptions<TQueryFnData, TError, TQueryData, TQueryKey>>;
 export type PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError> = DataSource<QueryDataSourceContext, TParams, TRequest, TResponse, TData, TError, QueryObserverExtendedOptions<NoInfer<TResponse>, NoInfer<TError>, ActualData<NoInfer<TData>, NoInfer<TResponse>>, NoInfer<TResponse>, DataSourceKey>, ResultWrapper<QueryObserverResult<ActualData<NoInfer<TData>, NoInfer<TResponse>>, NoInfer<TError>>, NoInfer<TResponse>, NoInfer<TData>, NoInfer<TError>>, QueryFunctionContext<DataSourceKey>> & {
     type: 'plain';
 };

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

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

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

@@ -16,3 +16,5 @@ export type { ProgressiveRefetchOptions } from './utils/getProgressiveRefetch';
 export { getProgressiveRefetch } from './utils/getProgressiveRefetch';
 export type { ClientDataManagerConfig } from './ClientDataManager';
 export { ClientDataManager } from './ClientDataManager';
+export { DataSourceProvider } from './DataSourceProvider';
+export type { QueryNormalizer } from './types/normalizer';

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

@@ -10,4 +10,5 @@ export { composeOptions as composePlainQueryOptions } from './impl/plain/utils';
 export { normalizeStatus } from './utils/normalizeStatus';
 export { getProgressiveRefetch } from './utils/getProgressiveRefetch';
 export { ClientDataManager } from './ClientDataManager';
+export { DataSourceProvider } from './DataSourceProvider';
 // #sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["useQueryContext","useQueryData","useQueryResponses","useRefetchAll","useRefetchErrored","makeInfiniteQueryDataSource","composeOptions","composeInfiniteQueryOptions","makePlainQueryDataSource","composePlainQueryOptions","normalizeStatus","getProgressiveRefetch","ClientDataManager"],"sources":["index.ts"],"sourcesContent":["export type {QueryDataSourceContext, AnyQueryDataSource} from './types/base';\nexport type {RefetchIntervalFunction, RefetchInterval} from './types/refetch-interval';\n\nexport {useQueryContext} from './hooks/useQueryContext';\nexport {useQueryData} from './hooks/useQueryData';\nexport {useQueryResponses} from './hooks/useQueryResponses';\nexport {useRefetchAll} from './hooks/useRefetchAll';\nexport {useRefetchErrored} from './hooks/useRefetchErrored';\n\nexport type {InfiniteQueryDataSource, AnyInfiniteQueryDataSource} from './impl/infinite/types';\nexport {makeInfiniteQueryDataSource} from './impl/infinite/factory';\nexport {composeOptions as composeInfiniteQueryOptions} from './impl/infinite/utils';\n\nexport type {PlainQueryDataSource, AnyPlainQueryDataSource} from './impl/plain/types';\nexport {makePlainQueryDataSource} from './impl/plain/factory';\nexport {composeOptions as composePlainQueryOptions} from './impl/plain/utils';\n\nexport {normalizeStatus} from './utils/normalizeStatus';\nexport type {ProgressiveRefetchOptions} from './utils/getProgressiveRefetch';\nexport {getProgressiveRefetch} from './utils/getProgressiveRefetch';\n\nexport type {ClientDataManagerConfig} from './ClientDataManager';\nexport {ClientDataManager} from './ClientDataManager';\n"],"mappings":"AAGA,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;AAEvD,SAAQC,qBAAqB,QAAO,+BAA+B;AAGnE,SAAQC,iBAAiB,QAAO,qBAAqB","ignoreList":[]}
+{"version":3,"names":["useQueryContext","useQueryData","useQueryResponses","useRefetchAll","useRefetchErrored","makeInfiniteQueryDataSource","composeOptions","composeInfiniteQueryOptions","makePlainQueryDataSource","composePlainQueryOptions","normalizeStatus","getProgressiveRefetch","ClientDataManager","DataSourceProvider"],"sources":["index.ts"],"sourcesContent":["export type {QueryDataSourceContext, AnyQueryDataSource} from './types/base';\nexport type {RefetchIntervalFunction, RefetchInterval} from './types/refetch-interval';\n\nexport {useQueryContext} from './hooks/useQueryContext';\nexport {useQueryData} from './hooks/useQueryData';\nexport {useQueryResponses} from './hooks/useQueryResponses';\nexport {useRefetchAll} from './hooks/useRefetchAll';\nexport {useRefetchErrored} from './hooks/useRefetchErrored';\n\nexport type {InfiniteQueryDataSource, AnyInfiniteQueryDataSource} from './impl/infinite/types';\nexport {makeInfiniteQueryDataSource} from './impl/infinite/factory';\nexport {composeOptions as composeInfiniteQueryOptions} from './impl/infinite/utils';\n\nexport type {PlainQueryDataSource, AnyPlainQueryDataSource} from './impl/plain/types';\nexport {makePlainQueryDataSource} from './impl/plain/factory';\nexport {composeOptions as composePlainQueryOptions} from './impl/plain/utils';\n\nexport {normalizeStatus} from './utils/normalizeStatus';\nexport type {ProgressiveRefetchOptions} from './utils/getProgressiveRefetch';\nexport {getProgressiveRefetch} from './utils/getProgressiveRefetch';\n\nexport type {ClientDataManagerConfig} from './ClientDataManager';\nexport {ClientDataManager} from './ClientDataManager';\n\nexport {DataSourceProvider} from './DataSourceProvider';\n\nexport type {QueryNormalizer} from './types/normalizer';\n"],"mappings":"AAGA,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;AAEvD,SAAQC,qBAAqB,QAAO,+BAA+B;AAGnE,SAAQC,iBAAiB,QAAO,qBAAqB;AAErD,SAAQC,kBAAkB,QAAO,sBAAsB","ignoreList":[]}

package/build/esm/react-query/types/normalizer.d.ts

@@ -0,0 +1,21 @@
+import type { Data, NormalizedData } from '@normy/core/types/types';
+export interface QueryNormalizer {
+    /** Get normalized data */
+    getNormalizedData: () => NormalizedData;
+    /** Set normalized data (for manual updates, WebSocket, etc.) */
+    setNormalizedData: (data: Data) => void;
+    /** Clear all normalized data */
+    clear: () => void;
+    /** Get object by ID */
+    getObjectById: <T extends Data>(id: string, exampleObject?: T) => T | undefined;
+    /** Get query fragment */
+    getQueryFragment: <T extends Data>(fragment: Data, exampleObject?: T) => T | undefined;
+    /** Get dependent queries by data */
+    getDependentQueries: (mutationData: Data) => ReadonlyArray<readonly unknown[]>;
+    /** Get dependent queries by IDs */
+    getDependentQueriesByIds: (ids: ReadonlyArray<string>) => ReadonlyArray<readonly unknown[]>;
+    /** Subscribe to QueryCache changes */
+    subscribe: () => void;
+    /** Unsubscribe from QueryCache changes */
+    unsubscribe: () => void;
+}

package/build/esm/react-query/types/normalizer.js

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

package/build/esm/react-query/types/normalizer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["normalizer.ts"],"sourcesContent":["import type {Data, NormalizedData} from '@normy/core/types/types';\n\nexport interface QueryNormalizer {\n    /** Get normalized data */\n    getNormalizedData: () => NormalizedData;\n    /** Set normalized data (for manual updates, WebSocket, etc.) */\n    setNormalizedData: (data: Data) => void;\n    /** Clear all normalized data */\n    clear: () => void;\n    /** Get object by ID */\n    getObjectById: <T extends Data>(id: string, exampleObject?: T) => T | undefined;\n    /** Get query fragment */\n    getQueryFragment: <T extends Data>(fragment: Data, exampleObject?: T) => T | undefined;\n    /** Get dependent queries by data */\n    getDependentQueries: (mutationData: Data) => ReadonlyArray<readonly unknown[]>;\n    /** Get dependent queries by IDs */\n    getDependentQueriesByIds: (ids: ReadonlyArray<string>) => ReadonlyArray<readonly unknown[]>;\n    /** Subscribe to QueryCache changes */\n    subscribe: () => void;\n    /** Unsubscribe from QueryCache changes */\n    unsubscribe: () => void;\n}\n"],"mappings":"","ignoreList":[]}

package/build/esm/react-query/types/options.d.ts

@@ -1,5 +1,17 @@
 import type { DefaultError, QueryKey } from '@tanstack/react-query';
+import type { OptimisticConfig } from '../../core/types/Normalizer';
 import type { RefetchInterval } from './refetch-interval';
 export interface QueryDataAdditionalOptions<TQueryFnData = unknown, TError = DefaultError, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> {
     refetchInterval?: RefetchInterval<TQueryFnData, TError, TQueryData, TQueryKey>;
+    /**
+     * @deprecated The use of the enabled option is deprecated.
+     * It is recommended to use idle as query parameters to control query state.
+     */
+    enabled?: boolean;
+    /** Normalization configuration (enable/disable) */
+    normalize?: boolean;
+    /** Optimistic data update configuration */
+    optimistic?: boolean | OptimisticConfig;
+    /** Invalidate data configuration */
+    invalidate?: boolean;
 }

package/build/esm/react-query/types/options.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["options.ts"],"sourcesContent":["import type {DefaultError, QueryKey} from '@tanstack/react-query';\n\nimport type {RefetchInterval} from './refetch-interval';\n\nexport interface QueryDataAdditionalOptions<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TQueryData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n> {\n    refetchInterval?: RefetchInterval<TQueryFnData, TError, TQueryData, TQueryKey>;\n}\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["options.ts"],"sourcesContent":["import type {DefaultError, QueryKey} from '@tanstack/react-query';\n\nimport type {OptimisticConfig} from '../../core/types/Normalizer';\n\nimport type {RefetchInterval} from './refetch-interval';\n\nexport interface QueryDataAdditionalOptions<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TQueryData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n> {\n    refetchInterval?: RefetchInterval<TQueryFnData, TError, TQueryData, TQueryKey>;\n    /**\n     * @deprecated The use of the enabled option is deprecated.\n     * It is recommended to use idle as query parameters to control query state.\n     */\n    enabled?: boolean;\n    /** Normalization configuration (enable/disable) */\n    normalize?: boolean;\n    /** Optimistic data update configuration */\n    optimistic?: boolean | OptimisticConfig;\n    /** Invalidate data configuration */\n    invalidate?: boolean;\n}\n"],"mappings":"","ignoreList":[]}

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

@@ -0,0 +1,22 @@
+import type { Data } from '@normy/core';
+import type { QueryClient } from '@tanstack/react-query';
+import type { Normalizer, NormalizerConfig } from '../../core/types/Normalizer';
+export declare const createQueryNormalizer: (normalizer: Normalizer | undefined, queryClient: QueryClient, config: boolean | NormalizerConfig | undefined, optimisticUpdate: (mutationData: Data) => void, invalidateData: (data: Data) => void) => {
+    /** Get normalized data */
+    getNormalizedData: () => import("@normy/core/types/types").NormalizedData;
+    /** Set normalized data (for manual updates, WebSocket, etc.) */
+    setNormalizedData: (data: Data) => void;
+    /** Clear all normalized data */
+    clear: () => void;
+    /** Get object by ID */
+    getObjectById: <T extends Data>(id: string, exampleObject?: T) => T | undefined;
+    /** Get query fragment */
+    getQueryFragment: <T extends Data>(fragment: Data, exampleObject?: T) => T | undefined;
+    /** Get dependent queries by data */
+    getDependentQueries: (mutationData: Data) => (readonly unknown[])[];
+    /** Get dependent queries by IDs */
+    getDependentQueriesByIds: (ids: ReadonlyArray<string>) => (readonly unknown[])[];
+    /** Subscribe to QueryCache changes */
+    subscribe: () => void;
+    unsubscribe: () => void;
+} | undefined;

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

@@ -0,0 +1,143 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+var shouldInvalidateData = function shouldInvalidateData(globalConfig, mutationConfig) {
+  if (mutationConfig === false) {
+    return false;
+  }
+  if (!globalConfig) {
+    return false;
+  }
+  return true;
+};
+var shouldUpdateOptimistically = function shouldUpdateOptimistically(globalConfig, mutationConfig) {
+  if (mutationConfig === false) {
+    return false;
+  }
+  if (typeof mutationConfig === 'boolean' && mutationConfig || _typeof(mutationConfig) === 'object' && mutationConfig) {
+    return true;
+  }
+  if (!globalConfig) {
+    return false;
+  }
+  return true;
+};
+var getOptimisticProps = function getOptimisticProps(globalConfig, mutationConfig) {
+  var globalAutoRollback = _typeof(globalConfig) === 'object' ? globalConfig.autoCalculateRollback : undefined;
+  var mutationAutoRollback = _typeof(mutationConfig) === 'object' ? mutationConfig.autoCalculateRollback : undefined;
+  var globalDevLogging = _typeof(globalConfig) === 'object' ? globalConfig.devLogging : undefined;
+  var mutationDevLogging = _typeof(mutationConfig) === 'object' ? mutationConfig.devLogging : undefined;
+  return {
+    autoRollback: mutationAutoRollback !== null && mutationAutoRollback !== void 0 ? mutationAutoRollback : globalAutoRollback,
+    devLogging: mutationDevLogging !== null && mutationDevLogging !== void 0 ? mutationDevLogging : globalDevLogging
+  };
+};
+export var createQueryNormalizer = function createQueryNormalizer(normalizer, queryClient, config, optimisticUpdate, invalidateData) {
+  if (!normalizer || !config) {
+    return undefined;
+  }
+  var globalOptimistic = _typeof(config) === 'object' && 'optimistic' in config ? config.optimistic : false;
+  var globalInvalidateData = _typeof(config) === 'object' && 'invalidate' in config ? config.invalidate : false;
+  var unsubscribeQueryCache = null;
+  var unsubscribeMutationCache = null;
+  return {
+    /** Get normalized data */
+    getNormalizedData: normalizer.getNormalizedData,
+    /** Set normalized data (for manual updates, WebSocket, etc.) */
+    setNormalizedData: function setNormalizedData(data) {
+      return optimisticUpdate(data);
+    },
+    /** Clear all normalized data */
+    clear: normalizer.clearNormalizedData,
+    /** Get object by ID */
+    getObjectById: normalizer.getObjectById,
+    /** Get query fragment */
+    getQueryFragment: normalizer.getQueryFragment,
+    /** Get dependent queries by data */
+    getDependentQueries: function getDependentQueries(mutationData) {
+      return normalizer.getDependentQueries(mutationData).map(function (key) {
+        return JSON.parse(key);
+      });
+    },
+    /** Get dependent queries by IDs */
+    getDependentQueriesByIds: function getDependentQueriesByIds(ids) {
+      return normalizer.getDependentQueriesByIds(ids).map(function (key) {
+        return JSON.parse(key);
+      });
+    },
+    /** Subscribe to QueryCache changes */
+    subscribe: function subscribe() {
+      // Subscribe to QueryCache (query additions/updates/removals)
+      unsubscribeQueryCache = queryClient.getQueryCache().subscribe(function (event) {
+        var _queryOptions$normali;
+        var queryKeyStr = JSON.stringify(event.query.queryKey);
+        if (event.type === 'removed') {
+          normalizer.removeQuery(queryKeyStr);
+          return;
+        }
+
+        // Check if the query should be normalized
+        // At this point options are already merged (DataSource + Hook)
+        var queryOptions = event.query.options;
+        var queryNormalize = (_queryOptions$normali = queryOptions === null || queryOptions === void 0 ? void 0 : queryOptions.normalize) !== null && _queryOptions$normali !== void 0 ? _queryOptions$normali : true;
+        if (!queryNormalize) {
+          return;
+        }
+        if (event.type === 'added' && event.query.state.data !== undefined) {
+          normalizer.setQuery(queryKeyStr, event.query.state.data);
+        } else if (event.type === 'updated' && event.action.type === 'success' && event.action.data !== undefined) {
+          normalizer.setQuery(queryKeyStr, event.action.data);
+        }
+      });
+
+      // Subscribe to MutationCache for normalization + optimistic updates
+      unsubscribeMutationCache = queryClient.getMutationCache().subscribe(function (event) {
+        var _event$mutation;
+        // Cast to extended type with additional configs, if available
+        var mutationOptions = (_event$mutation = event.mutation) === null || _event$mutation === void 0 ? void 0 : _event$mutation.options;
+        var mutationQueryNormalize = mutationOptions === null || mutationOptions === void 0 ? void 0 : mutationOptions.normalize;
+        var mutationQueryOptimistic = mutationOptions === null || mutationOptions === void 0 ? void 0 : mutationOptions.optimistic;
+        var mutationQueryInvalidateData = mutationOptions === null || mutationOptions === void 0 ? void 0 : mutationOptions.invalidate;
+        if (shouldInvalidateData(globalInvalidateData, mutationQueryInvalidateData)) {
+          if (event.type === 'updated' && event.action.type === 'success' && event.action.data) {
+            invalidateData(event.action.data);
+          }
+        }
+        if (!mutationQueryNormalize || !shouldUpdateOptimistically(globalOptimistic, mutationQueryOptimistic)) {
+          return;
+        }
+        var _getOptimisticProps = getOptimisticProps(globalOptimistic, mutationQueryOptimistic),
+          autoRollback = _getOptimisticProps.autoRollback,
+          devLogging = _getOptimisticProps.devLogging;
+        if (event.type === 'updated' && event.action.type === 'success' && event.action.data) {
+          optimisticUpdate(event.action.data);
+        } else if (event.type === 'updated' && event.action.type === 'pending') {
+          var context = event.mutation.state.context;
+          if (context !== null && context !== void 0 && context.optimisticData) {
+            if (!context.rollbackData && mutationQueryOptimistic && autoRollback !== false) {
+              context.rollbackData = normalizer.getCurrentData(context.optimisticData);
+              if (devLogging) {
+                console.log('[OptimisticUpdate] Auto-calculated rollbackData:', context.rollbackData);
+              }
+            }
+            optimisticUpdate(context.optimisticData);
+          }
+        } else if (event.type === 'updated' && event.action.type === 'error') {
+          var _context = event.mutation.state.context;
+          if (_context !== null && _context !== void 0 && _context.rollbackData) {
+            if (devLogging) {
+              console.log('[OptimisticUpdate] Rolling back changes');
+            }
+            optimisticUpdate(_context.rollbackData);
+          }
+        }
+      });
+    },
+    unsubscribe: function unsubscribe() {
+      var _unsubscribeQueryCach, _unsubscribeMutationC;
+      (_unsubscribeQueryCach = unsubscribeQueryCache) === null || _unsubscribeQueryCach === void 0 || _unsubscribeQueryCach();
+      (_unsubscribeMutationC = unsubscribeMutationCache) === null || _unsubscribeMutationC === void 0 || _unsubscribeMutationC();
+      unsubscribeQueryCache = null;
+      unsubscribeMutationCache = null;
+    }
+  };
+};
+// #sourceMappingURL=normalize.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["shouldInvalidateData","globalConfig","mutationConfig","shouldUpdateOptimistically","_typeof","getOptimisticProps","globalAutoRollback","autoCalculateRollback","undefined","mutationAutoRollback","globalDevLogging","devLogging","mutationDevLogging","autoRollback","createQueryNormalizer","normalizer","queryClient","config","optimisticUpdate","invalidateData","globalOptimistic","optimistic","globalInvalidateData","invalidate","unsubscribeQueryCache","unsubscribeMutationCache","getNormalizedData","setNormalizedData","data","clear","clearNormalizedData","getObjectById","getQueryFragment","getDependentQueries","mutationData","map","key","JSON","parse","getDependentQueriesByIds","ids","subscribe","getQueryCache","event","_queryOptions$normali","queryKeyStr","stringify","query","queryKey","type","removeQuery","queryOptions","options","queryNormalize","normalize","state","setQuery","action","getMutationCache","_event$mutation","mutationOptions","mutation","mutationQueryNormalize","mutationQueryOptimistic","mutationQueryInvalidateData","_getOptimisticProps","context","optimisticData","rollbackData","getCurrentData","console","log","unsubscribe","_unsubscribeQueryCach","_unsubscribeMutationC"],"sources":["normalize.ts"],"sourcesContent":["import type {Data} from '@normy/core';\nimport type {QueryClient, QueryKey} from '@tanstack/react-query';\n\nimport type {Normalizer, NormalizerConfig, OptimisticConfig} from '../../core/types/Normalizer';\nimport type {QueryDataAdditionalOptions} from '../types/options';\n\ninterface QueryNormalizeOptions {\n    normalize?: boolean;\n    optimistic?: boolean | OptimisticConfig;\n    invalidate?: boolean;\n}\n\nconst shouldInvalidateData = (globalConfig?: boolean, mutationConfig?: boolean): boolean => {\n    if (mutationConfig === false) {\n        return false;\n    }\n\n    if (!globalConfig) {\n        return false;\n    }\n\n    return true;\n};\n\nconst shouldUpdateOptimistically = (\n    globalConfig?: boolean | OptimisticConfig,\n    mutationConfig?: boolean | OptimisticConfig,\n): boolean => {\n    if (mutationConfig === false) {\n        return false;\n    }\n\n    if (\n        (typeof mutationConfig === 'boolean' && mutationConfig) ||\n        (typeof mutationConfig === 'object' && mutationConfig)\n    ) {\n        return true;\n    }\n\n    if (!globalConfig) {\n        return false;\n    }\n\n    return true;\n};\n\nconst getOptimisticProps = (\n    globalConfig?: boolean | OptimisticConfig,\n    mutationConfig?: boolean | OptimisticConfig,\n) => {\n    const globalAutoRollback =\n        typeof globalConfig === 'object' ? globalConfig.autoCalculateRollback : undefined;\n    const mutationAutoRollback =\n        typeof mutationConfig === 'object' ? mutationConfig.autoCalculateRollback : undefined;\n    const globalDevLogging = typeof globalConfig === 'object' ? globalConfig.devLogging : undefined;\n    const mutationDevLogging =\n        typeof mutationConfig === 'object' ? mutationConfig.devLogging : undefined;\n\n    return {\n        autoRollback: mutationAutoRollback ?? globalAutoRollback,\n        devLogging: mutationDevLogging ?? globalDevLogging,\n    };\n};\n\nexport const createQueryNormalizer = (\n    normalizer: Normalizer | undefined,\n    queryClient: QueryClient,\n    config: boolean | NormalizerConfig | undefined,\n    optimisticUpdate: (mutationData: Data) => void,\n    invalidateData: (data: Data) => void,\n) => {\n    if (!normalizer || !config) {\n        return undefined;\n    }\n\n    const globalOptimistic =\n        typeof config === 'object' && 'optimistic' in config ? config.optimistic : false;\n\n    const globalInvalidateData =\n        typeof config === 'object' && 'invalidate' in config ? config.invalidate : false;\n\n    let unsubscribeQueryCache: (() => void) | null = null;\n    let unsubscribeMutationCache: (() => void) | null = null;\n\n    return {\n        /** Get normalized data */\n        getNormalizedData: normalizer.getNormalizedData,\n        /** Set normalized data (for manual updates, WebSocket, etc.) */\n        setNormalizedData: (data: Data) => optimisticUpdate(data),\n        /** Clear all normalized data */\n        clear: normalizer.clearNormalizedData,\n        /** Get object by ID */\n        getObjectById: normalizer.getObjectById,\n        /** Get query fragment */\n        getQueryFragment: normalizer.getQueryFragment,\n        /** Get dependent queries by data */\n        getDependentQueries: (mutationData: Data) =>\n            normalizer.getDependentQueries(mutationData).map((key) => JSON.parse(key) as QueryKey),\n        /** Get dependent queries by IDs */\n        getDependentQueriesByIds: (ids: ReadonlyArray<string>) =>\n            normalizer.getDependentQueriesByIds(ids).map((key) => JSON.parse(key) as QueryKey),\n        /** Subscribe to QueryCache changes */\n        subscribe: () => {\n            // Subscribe to QueryCache (query additions/updates/removals)\n            unsubscribeQueryCache = queryClient.getQueryCache().subscribe((event) => {\n                const queryKeyStr = JSON.stringify(event.query.queryKey);\n\n                if (event.type === 'removed') {\n                    normalizer.removeQuery(queryKeyStr);\n\n                    return;\n                }\n\n                // Check if the query should be normalized\n                // At this point options are already merged (DataSource + Hook)\n                const queryOptions = event.query.options as QueryDataAdditionalOptions;\n\n                const queryNormalize = queryOptions?.normalize ?? true;\n\n                if (!queryNormalize) {\n                    return;\n                }\n\n                if (event.type === 'added' && event.query.state.data !== undefined) {\n                    normalizer.setQuery(queryKeyStr, event.query.state.data as Data);\n                } else if (\n                    event.type === 'updated' &&\n                    event.action.type === 'success' &&\n                    event.action.data !== undefined\n                ) {\n                    normalizer.setQuery(queryKeyStr, event.action.data as Data);\n                }\n            });\n\n            // Subscribe to MutationCache for normalization + optimistic updates\n            unsubscribeMutationCache = queryClient.getMutationCache().subscribe((event) => {\n                // Cast to extended type with additional configs, if available\n                const mutationOptions = event.mutation?.options as\n                    | QueryNormalizeOptions\n                    | undefined;\n\n                const mutationQueryNormalize = mutationOptions?.normalize;\n                const mutationQueryOptimistic = mutationOptions?.optimistic;\n                const mutationQueryInvalidateData = mutationOptions?.invalidate;\n\n                if (shouldInvalidateData(globalInvalidateData, mutationQueryInvalidateData)) {\n                    if (\n                        event.type === 'updated' &&\n                        event.action.type === 'success' &&\n                        event.action.data\n                    ) {\n                        invalidateData(event.action.data as Data);\n                    }\n                }\n\n                if (\n                    !mutationQueryNormalize ||\n                    !shouldUpdateOptimistically(globalOptimistic, mutationQueryOptimistic)\n                ) {\n                    return;\n                }\n\n                const {autoRollback, devLogging} = getOptimisticProps(\n                    globalOptimistic,\n                    mutationQueryOptimistic,\n                );\n\n                if (\n                    event.type === 'updated' &&\n                    event.action.type === 'success' &&\n                    event.action.data\n                ) {\n                    optimisticUpdate(event.action.data as Data);\n                } else if (event.type === 'updated' && event.action.type === 'pending') {\n                    const context = event.mutation.state.context as {\n                        optimisticData?: Data;\n                        rollbackData?: Data;\n                    };\n\n                    if (context?.optimisticData) {\n                        if (\n                            !context.rollbackData &&\n                            mutationQueryOptimistic &&\n                            autoRollback !== false\n                        ) {\n                            context.rollbackData = normalizer.getCurrentData(\n                                context.optimisticData,\n                            );\n\n                            if (devLogging) {\n                                console.log(\n                                    '[OptimisticUpdate] Auto-calculated rollbackData:',\n                                    context.rollbackData,\n                                );\n                            }\n                        }\n\n                        optimisticUpdate(context.optimisticData);\n                    }\n                } else if (event.type === 'updated' && event.action.type === 'error') {\n                    const context = event.mutation.state.context as {\n                        rollbackData?: Data;\n                    };\n\n                    if (context?.rollbackData) {\n                        if (devLogging) {\n                            console.log('[OptimisticUpdate] Rolling back changes');\n                        }\n\n                        optimisticUpdate(context.rollbackData);\n                    }\n                }\n            });\n        },\n        unsubscribe: () => {\n            unsubscribeQueryCache?.();\n            unsubscribeMutationCache?.();\n            unsubscribeQueryCache = null;\n            unsubscribeMutationCache = null;\n        },\n    };\n};\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1 @@
+export declare function warn(msg: string): void;

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

@@ -0,0 +1,9 @@
+export function warn(msg) {
+  if (!msg || process.env.NODE_ENV === 'production') {
+    return;
+  }
+
+  // eslint-disable-next-line no-console
+  console.warn(msg);
+}
+// #sourceMappingURL=warn.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["warn","msg","process","env","NODE_ENV","console"],"sources":["warn.ts"],"sourcesContent":["export function warn(msg: string) {\n    if (!msg || process.env.NODE_ENV === 'production') {\n        return;\n    }\n\n    // eslint-disable-next-line no-console\n    console.warn(msg);\n}\n"],"mappings":"AAAA,OAAO,SAASA,IAAIA,CAACC,GAAW,EAAE;EAC9B,IAAI,CAACA,GAAG,IAAIC,OAAO,CAACC,GAAG,CAACC,QAAQ,KAAK,YAAY,EAAE;IAC/C;EACJ;;EAEA;EACAC,OAAO,CAACL,IAAI,CAACC,GAAG,CAAC;AACrB","ignoreList":[]}

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

@@ -0,0 +1 @@
+export declare const warnDisabledRefetch: () => void;

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

@@ -0,0 +1,5 @@
+import { warn } from './warn';
+export var warnDisabledRefetch = function warnDisabledRefetch() {
+  warn('Disabled refetch is called');
+};
+// #sourceMappingURL=warnDisabledRefetch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["warn","warnDisabledRefetch"],"sources":["warnDisabledRefetch.ts"],"sourcesContent":["import {warn} from './warn';\n\nexport const warnDisabledRefetch = () => {\n    warn('Disabled refetch is called');\n};\n"],"mappings":"AAAA,SAAQA,IAAI,QAAO,QAAQ;AAE3B,OAAO,IAAMC,mBAAmB,GAAG,SAAtBA,mBAAmBA,CAAA,EAAS;EACrCD,IAAI,CAAC,4BAA4B,CAAC;AACtC,CAAC","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/data-source",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "A wrapper around data fetching",
   "keywords": [
     "data-fetching",
@@ -43,6 +43,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@normy/core": "^0.14.0",
     "utility-types": "^3.11.0"
   },
   "devDependencies": {