@gravity-ui/data-source 0.8.2 → 0.9.1-alpha.0

package/build/esm/react-query/components/QueryAsyncBoundary/QueryAsyncBoundary.js

@@ -0,0 +1,16 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import React from 'react';
+import { QueryErrorResetBoundary } from '@tanstack/react-query';
+import { AsyncBoundary } from '../../../react';
+import { jsx as _jsx } from "react/jsx-runtime";
+export var QueryAsyncBoundary = function QueryAsyncBoundary(props) {
+  return /*#__PURE__*/_jsx(QueryErrorResetBoundary, {
+    children: function children(_ref) {
+      var reset = _ref.reset;
+      return /*#__PURE__*/_jsx(AsyncBoundary, _objectSpread({
+        onReset: reset
+      }, props));
+    }
+  });
+};
+// #sourceMappingURL=QueryAsyncBoundary.js.map

package/build/esm/react-query/components/QueryAsyncBoundary/QueryAsyncBoundary.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","QueryErrorResetBoundary","AsyncBoundary","jsx","_jsx","QueryAsyncBoundary","props","children","_ref","reset","_objectSpread","onReset"],"sources":["QueryAsyncBoundary.tsx"],"sourcesContent":["import React from 'react';\n\nimport {QueryErrorResetBoundary} from '@tanstack/react-query';\n\nimport {AsyncBoundary} from '../../../react';\n\nimport type {QueryAsyncBoundaryProps} from './types';\n\nexport const QueryAsyncBoundary: React.FC<QueryAsyncBoundaryProps> = (props) => (\n    <QueryErrorResetBoundary>\n        {({reset}) => <AsyncBoundary onReset={reset} {...props} />}\n    </QueryErrorResetBoundary>\n);\n"],"mappings":";AAAA,OAAOA,KAAK,MAAM,OAAO;AAEzB,SAAQC,uBAAuB,QAAO,uBAAuB;AAE7D,SAAQC,aAAa,QAAO,gBAAgB;AAAC,SAAAC,GAAA,IAAAC,IAAA;AAI7C,OAAO,IAAMC,kBAAqD,GAAG,SAAxDA,kBAAqDA,CAAIC,KAAK;EAAA,oBACvEF,IAAA,CAACH,uBAAuB;IAAAM,QAAA,EACnB,SAAAA,SAAAC,IAAA;MAAA,IAAEC,KAAK,GAAAD,IAAA,CAALC,KAAK;MAAA,oBAAML,IAAA,CAACF,aAAa,EAAAQ,aAAA;QAACC,OAAO,EAAEF;MAAM,GAAKH,KAAK,CAAG,CAAC;IAAA;EAAA,CACrC,CAAC;AAAA,CAC7B","ignoreList":[]}

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

@@ -0,0 +1,3 @@
+export { QueryAsyncBoundary } from './QueryAsyncBoundary';
+export type { QueryAsyncBoundaryProps, QueryAsyncBoundaryComponent } from './types';
+export { withQueryAsyncBoundary } from './withQueryAsyncBoundary';

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

@@ -0,0 +1,3 @@
+export { QueryAsyncBoundary } from './QueryAsyncBoundary';
+export { withQueryAsyncBoundary } from './withQueryAsyncBoundary';
+// #sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["QueryAsyncBoundary","withQueryAsyncBoundary"],"sources":["index.ts"],"sourcesContent":["export {QueryAsyncBoundary} from './QueryAsyncBoundary';\nexport type {QueryAsyncBoundaryProps, QueryAsyncBoundaryComponent} from './types';\nexport {withQueryAsyncBoundary} from './withQueryAsyncBoundary';\n"],"mappings":"AAAA,SAAQA,kBAAkB,QAAO,sBAAsB;AAEvD,SAAQC,sBAAsB,QAAO,0BAA0B","ignoreList":[]}

package/build/esm/react-query/components/QueryAsyncBoundary/types.d.ts

@@ -0,0 +1,8 @@
+import type { AsyncBoundaryProps } from '../../../react';
+export interface QueryAsyncBoundaryProps extends AsyncBoundaryProps {
+}
+export interface QueryAsyncBoundaryComponent<TProps extends object> extends React.FC<TProps> {
+    Content: React.ComponentType<TProps>;
+    Loading: QueryAsyncBoundaryProps['LoadingView'];
+    Error: QueryAsyncBoundaryProps['ErrorView'];
+}

package/build/esm/react-query/components/QueryAsyncBoundary/types.js

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

package/build/esm/react-query/components/QueryAsyncBoundary/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type {AsyncBoundaryProps} from '../../../react';\n\nexport interface QueryAsyncBoundaryProps extends AsyncBoundaryProps {}\n\nexport interface QueryAsyncBoundaryComponent<TProps extends object> extends React.FC<TProps> {\n    Content: React.ComponentType<TProps>;\n    Loading: QueryAsyncBoundaryProps['LoadingView'];\n    Error: QueryAsyncBoundaryProps['ErrorView'];\n}\n"],"mappings":"","ignoreList":[]}

package/build/esm/react-query/components/QueryAsyncBoundary/withQueryAsyncBoundary.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { QueryAsyncBoundaryComponent, QueryAsyncBoundaryProps } from './types';
+export declare const withQueryAsyncBoundary: <TProps extends object>(Component: React.ComponentType<TProps>, LoadingView: QueryAsyncBoundaryProps["LoadingView"], ErrorView: QueryAsyncBoundaryProps["ErrorView"]) => QueryAsyncBoundaryComponent<TProps>;

package/build/esm/react-query/components/QueryAsyncBoundary/withQueryAsyncBoundary.js

@@ -0,0 +1,19 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import React from 'react';
+import { QueryAsyncBoundary } from './QueryAsyncBoundary';
+import { jsx as _jsx } from "react/jsx-runtime";
+export var withQueryAsyncBoundary = function withQueryAsyncBoundary(Component, LoadingView, ErrorView) {
+  var WrappedComponent = function WrappedComponent(props) {
+    return /*#__PURE__*/_jsx(QueryAsyncBoundary, {
+      LoadingView: LoadingView,
+      ErrorView: ErrorView,
+      children: /*#__PURE__*/_jsx(Component, _objectSpread({}, props))
+    });
+  };
+  WrappedComponent.displayName = "WithQueryAsyncBoundary(".concat(Component.displayName || Component.name, ")");
+  WrappedComponent.Content = Component;
+  WrappedComponent.Loading = LoadingView;
+  WrappedComponent.Error = ErrorView;
+  return WrappedComponent;
+};
+// #sourceMappingURL=withQueryAsyncBoundary.js.map

package/build/esm/react-query/components/QueryAsyncBoundary/withQueryAsyncBoundary.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","QueryAsyncBoundary","jsx","_jsx","withQueryAsyncBoundary","Component","LoadingView","ErrorView","WrappedComponent","props","children","_objectSpread","displayName","concat","name","Content","Loading","Error"],"sources":["withQueryAsyncBoundary.tsx"],"sourcesContent":["import React from 'react';\n\nimport {QueryAsyncBoundary} from './QueryAsyncBoundary';\nimport type {QueryAsyncBoundaryComponent, QueryAsyncBoundaryProps} from './types';\n\nexport const withQueryAsyncBoundary = <TProps extends object>(\n    Component: React.ComponentType<TProps>,\n    LoadingView: QueryAsyncBoundaryProps['LoadingView'],\n    ErrorView: QueryAsyncBoundaryProps['ErrorView'],\n) => {\n    const WrappedComponent = ((props: TProps) => (\n        <QueryAsyncBoundary LoadingView={LoadingView} ErrorView={ErrorView}>\n            <Component {...props} />\n        </QueryAsyncBoundary>\n    )) as QueryAsyncBoundaryComponent<TProps>;\n\n    WrappedComponent.displayName = `WithQueryAsyncBoundary(${\n        Component.displayName || Component.name\n    })`;\n\n    WrappedComponent.Content = Component;\n    WrappedComponent.Loading = LoadingView;\n    WrappedComponent.Error = ErrorView;\n\n    return WrappedComponent;\n};\n"],"mappings":";AAAA,OAAOA,KAAK,MAAM,OAAO;AAEzB,SAAQC,kBAAkB,QAAO,sBAAsB;AAAC,SAAAC,GAAA,IAAAC,IAAA;AAGxD,OAAO,IAAMC,sBAAsB,GAAG,SAAzBA,sBAAsBA,CAC/BC,SAAsC,EACtCC,WAAmD,EACnDC,SAA+C,EAC9C;EACD,IAAMC,gBAAgB,GAAI,SAApBA,gBAAgBA,CAAKC,KAAa;IAAA,oBACpCN,IAAA,CAACF,kBAAkB;MAACK,WAAW,EAAEA,WAAY;MAACC,SAAS,EAAEA,SAAU;MAAAG,QAAA,eAC/DP,IAAA,CAACE,SAAS,EAAAM,aAAA,KAAKF,KAAK,CAAG;IAAC,CACR,CAAC;EAAA,CACgB;EAEzCD,gBAAgB,CAACI,WAAW,6BAAAC,MAAA,CACxBR,SAAS,CAACO,WAAW,IAAIP,SAAS,CAACS,IAAI,MACxC;EAEHN,gBAAgB,CAACO,OAAO,GAAGV,SAAS;EACpCG,gBAAgB,CAACQ,OAAO,GAAGV,WAAW;EACtCE,gBAAgB,CAACS,KAAK,GAAGV,SAAS;EAElC,OAAOC,gBAAgB;AAC3B,CAAC","ignoreList":[]}

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

@@ -0,0 +1,9 @@
+import type { Overwrite } from 'utility-types';
+import type { DataSourceData, DataSourceOptions, DataSourceParams, DataSourceState, idle } from '../../core';
+import type { AnyQueryDataSource } from '../types/base';
+type SuspenseQueryOptions<TDataSource extends AnyQueryDataSource> = Omit<Partial<DataSourceOptions<TDataSource>>, 'suspense' | 'enabled' | 'throwOnError' | 'retryOnMount' | 'placeholderData'>;
+type SuspenseQueryResult<TDataSource extends AnyQueryDataSource> = Overwrite<DataSourceState<TDataSource>, {
+    data: NonNullable<DataSourceData<TDataSource>>;
+}>;
+export declare const useSuspenseQueryData: <TDataSource extends AnyQueryDataSource>(dataSource: TDataSource, params: Exclude<DataSourceParams<TDataSource>, typeof idle>, options?: SuspenseQueryOptions<TDataSource>) => SuspenseQueryResult<TDataSource>;
+export {};

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

@@ -0,0 +1,15 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import { useQueryData } from './useQueryData';
+var defaultThrowOnError = function defaultThrowOnError(_error, query) {
+  return query.state.data === undefined;
+};
+export var useSuspenseQueryData = function useSuspenseQueryData(dataSource, params, options) {
+  return useQueryData(dataSource, params, _objectSpread(_objectSpread({}, options), {}, {
+    suspense: true,
+    enabled: true,
+    throwOnError: defaultThrowOnError,
+    retryOnMount: true,
+    placeholderData: undefined
+  }));
+};
+// #sourceMappingURL=useSuspenseQueryData.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useQueryData","defaultThrowOnError","_error","query","state","data","undefined","useSuspenseQueryData","dataSource","params","options","_objectSpread","suspense","enabled","throwOnError","retryOnMount","placeholderData"],"sources":["useSuspenseQueryData.ts"],"sourcesContent":["import type {Query} from '@tanstack/react-query';\nimport type {Overwrite} from 'utility-types';\n\nimport type {\n    DataSourceData,\n    DataSourceOptions,\n    DataSourceParams,\n    DataSourceState,\n    idle,\n} from '../../core';\nimport type {AnyQueryDataSource} from '../types/base';\n\nimport {useQueryData} from './useQueryData';\n\ntype SuspenseQueryOptions<TDataSource extends AnyQueryDataSource> = Omit<\n    Partial<DataSourceOptions<TDataSource>>,\n    'suspense' | 'enabled' | 'throwOnError' | 'retryOnMount' | 'placeholderData'\n>;\n\ntype SuspenseQueryResult<TDataSource extends AnyQueryDataSource> = Overwrite<\n    DataSourceState<TDataSource>,\n    {data: NonNullable<DataSourceData<TDataSource>>}\n>;\n\nconst defaultThrowOnError = (_error: unknown, query: Query) => query.state.data === undefined;\n\nexport const useSuspenseQueryData = <TDataSource extends AnyQueryDataSource>(\n    dataSource: TDataSource,\n    params: Exclude<DataSourceParams<TDataSource>, typeof idle>,\n    options?: SuspenseQueryOptions<TDataSource>,\n): SuspenseQueryResult<TDataSource> => {\n    return useQueryData(dataSource, params, {\n        ...options,\n        suspense: true,\n        enabled: true,\n        throwOnError: defaultThrowOnError,\n        retryOnMount: true,\n        placeholderData: undefined,\n    } as Partial<DataSourceOptions<TDataSource>>) as SuspenseQueryResult<TDataSource>;\n};\n"],"mappings":";AAYA,SAAQA,YAAY,QAAO,gBAAgB;AAY3C,IAAMC,mBAAmB,GAAG,SAAtBA,mBAAmBA,CAAIC,MAAe,EAAEC,KAAY;EAAA,OAAKA,KAAK,CAACC,KAAK,CAACC,IAAI,KAAKC,SAAS;AAAA;AAE7F,OAAO,IAAMC,oBAAoB,GAAG,SAAvBA,oBAAoBA,CAC7BC,UAAuB,EACvBC,MAA2D,EAC3DC,OAA2C,EACR;EACnC,OAAOV,YAAY,CAACQ,UAAU,EAAEC,MAAM,EAAAE,aAAA,CAAAA,aAAA,KAC/BD,OAAO;IACVE,QAAQ,EAAE,IAAI;IACdC,OAAO,EAAE,IAAI;IACbC,YAAY,EAAEb,mBAAmB;IACjCc,YAAY,EAAE,IAAI;IAClBC,eAAe,EAAEV;EAAS,EACc,CAAC;AACjD,CAAC","ignoreList":[]}

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

@@ -2,9 +2,11 @@ import _objectSpread from "@babel/runtime/helpers/objectSpread2";
 import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
 var _excluded = ["queryFn", "refetchInterval"];
 import { useMemo } from 'react';
-import { useInfiniteQuery } from '@tanstack/react-query';
+import { skipToken, useInfiniteQuery } from '@tanstack/react-query';
 import { useRefetchInterval } from '../../hooks/useRefetchInterval';
 import { normalizeStatus } from '../../utils/normalizeStatus';
+import { warnDisabledRefetch } from '../../utils/warnDisabledRefetch';
+import { wrapRefetch } from '../../utils/wrapRefetch';
 import { composeOptions } from './utils';
 var useInfiniteQueryDataOptions = function useInfiniteQueryDataOptions(composedOptions) {
   var queryFnOption = composedOptions.queryFn,
@@ -26,11 +28,13 @@ export var useInfiniteQueryData = function useInfiniteQueryData(context, dataSou
     var _state$data$pages$fla, _state$data;
     return (_state$data$pages$fla = (_state$data = state.data) === null || _state$data === void 0 ? void 0 : _state$data.pages.flat(1)) !== null && _state$data$pages$fla !== void 0 ? _state$data$pages$fla : [];
   }, [state.data]);
+  var isDisabled = composedOptions.enabled === false || composedOptions.queryFn === skipToken;
   return _objectSpread(_objectSpread({}, state), {}, {
     status: normalizeStatus(state.status, state.fetchStatus),
     data: transformedData,
     originalStatus: state.status,
-    originalData: state.data
+    originalData: state.data,
+    refetch: isDisabled ? warnDisabledRefetch : wrapRefetch(state.refetch)
   });
 };
 // #sourceMappingURL=hooks.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["useMemo","useInfiniteQuery","useRefetchInterval","normalizeStatus","composeOptions","useInfiniteQueryDataOptions","composedOptions","queryFnOption","queryFn","refetchIntervalOption","refetchInterval","restOptions","_objectWithoutProperties","_excluded","_useRefetchInterval","_objectSpread","useInfiniteQueryData","context","dataSource","params","options","extendedOptions","state","transformedData","_state$data$pages$fla","_state$data","data","pages","flat","status","fetchStatus","originalStatus","originalData"],"sources":["hooks.ts"],"sourcesContent":["import {useMemo} from 'react';\n\nimport {useInfiniteQuery} from '@tanstack/react-query';\nimport type {InfiniteData, InfiniteQueryObserverOptions} from '@tanstack/react-query';\n\nimport type {\n    DataSourceContext,\n    DataSourceData,\n    DataSourceError,\n    DataSourceKey,\n    DataSourceOptions,\n    DataSourceParams,\n    DataSourceRequest,\n    DataSourceResponse,\n    DataSourceState,\n} from '../../../core';\nimport {useRefetchInterval} from '../../hooks/useRefetchInterval';\nimport {normalizeStatus} from '../../utils/normalizeStatus';\n\nimport type {AnyInfiniteQueryDataSource, InfiniteQueryObserverExtendedOptions} from './types';\nimport {composeOptions} from './utils';\n\nconst useInfiniteQueryDataOptions = <TDataSource extends AnyInfiniteQueryDataSource>(\n    composedOptions: InfiniteQueryObserverExtendedOptions<\n        DataSourceResponse<TDataSource>,\n        DataSourceError<TDataSource>,\n        InfiniteData<DataSourceData<TDataSource>, Partial<DataSourceRequest<TDataSource>>>,\n        DataSourceResponse<TDataSource>,\n        DataSourceKey,\n        Partial<DataSourceRequest<TDataSource>>\n    >,\n): InfiniteQueryObserverOptions<\n    DataSourceResponse<TDataSource>,\n    DataSourceError<TDataSource>,\n    InfiniteData<DataSourceData<TDataSource>, Partial<DataSourceRequest<TDataSource>>>,\n    DataSourceResponse<TDataSource>,\n    DataSourceKey,\n    Partial<DataSourceRequest<TDataSource>>\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 useInfiniteQueryData = <TDataSource extends AnyInfiniteQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: Partial<DataSourceOptions<TDataSource>>,\n): DataSourceState<TDataSource> => {\n    const extendedOptions = composeOptions(context, dataSource, params, options);\n    const composedOptions = useInfiniteQueryDataOptions(extendedOptions);\n    const state = useInfiniteQuery(composedOptions);\n\n    const transformedData = useMemo<DataSourceState<TDataSource>['data']>(\n        () => state.data?.pages.flat(1) ?? [],\n        [state.data],\n    );\n\n    return {\n        ...state,\n        status: normalizeStatus(state.status, state.fetchStatus),\n        data: transformedData,\n        originalStatus: state.status,\n        originalData: state.data,\n    } as DataSourceState<TDataSource>;\n};\n"],"mappings":";;;AAAA,SAAQA,OAAO,QAAO,OAAO;AAE7B,SAAQC,gBAAgB,QAAO,uBAAuB;AActD,SAAQC,kBAAkB,QAAO,gCAAgC;AACjE,SAAQC,eAAe,QAAO,6BAA6B;AAG3D,SAAQC,cAAc,QAAO,SAAS;AAEtC,IAAMC,2BAA2B,GAAG,SAA9BA,2BAA2BA,CAC7BC,eAOC,EAQA;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,oBAAoB,GAAG,SAAvBA,oBAAoBA,CAC7BC,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,2BAA2B,CAACgB,eAAe,CAAC;EACpE,IAAMC,KAAK,GAAGrB,gBAAgB,CAACK,eAAe,CAAC;EAE/C,IAAMiB,eAAe,GAAGvB,OAAO,CAC3B;IAAA,IAAAwB,qBAAA,EAAAC,WAAA;IAAA,QAAAD,qBAAA,IAAAC,WAAA,GAAMH,KAAK,CAACI,IAAI,cAAAD,WAAA,uBAAVA,WAAA,CAAYE,KAAK,CAACC,IAAI,CAAC,CAAC,CAAC,cAAAJ,qBAAA,cAAAA,qBAAA,GAAI,EAAE;EAAA,GACrC,CAACF,KAAK,CAACI,IAAI,CACf,CAAC;EAED,OAAAX,aAAA,CAAAA,aAAA,KACOO,KAAK;IACRO,MAAM,EAAE1B,eAAe,CAACmB,KAAK,CAACO,MAAM,EAAEP,KAAK,CAACQ,WAAW,CAAC;IACxDJ,IAAI,EAAEH,eAAe;IACrBQ,cAAc,EAAET,KAAK,CAACO,MAAM;IAC5BG,YAAY,EAAEV,KAAK,CAACI;EAAI;AAEhC,CAAC","ignoreList":[]}
+{"version":3,"names":["useMemo","skipToken","useInfiniteQuery","useRefetchInterval","normalizeStatus","warnDisabledRefetch","wrapRefetch","composeOptions","useInfiniteQueryDataOptions","composedOptions","queryFnOption","queryFn","refetchIntervalOption","refetchInterval","restOptions","_objectWithoutProperties","_excluded","_useRefetchInterval","_objectSpread","useInfiniteQueryData","context","dataSource","params","options","extendedOptions","state","transformedData","_state$data$pages$fla","_state$data","data","pages","flat","isDisabled","enabled","status","fetchStatus","originalStatus","originalData","refetch"],"sources":["hooks.ts"],"sourcesContent":["import {useMemo} from 'react';\n\nimport {skipToken, useInfiniteQuery} from '@tanstack/react-query';\nimport type {InfiniteData, InfiniteQueryObserverOptions} from '@tanstack/react-query';\n\nimport type {\n    DataSourceContext,\n    DataSourceData,\n    DataSourceError,\n    DataSourceKey,\n    DataSourceOptions,\n    DataSourceParams,\n    DataSourceRequest,\n    DataSourceResponse,\n    DataSourceState,\n} from '../../../core';\nimport {useRefetchInterval} from '../../hooks/useRefetchInterval';\nimport {normalizeStatus} from '../../utils/normalizeStatus';\nimport {warnDisabledRefetch} from '../../utils/warnDisabledRefetch';\nimport {wrapRefetch} from '../../utils/wrapRefetch';\n\nimport type {AnyInfiniteQueryDataSource, InfiniteQueryObserverExtendedOptions} from './types';\nimport {composeOptions} from './utils';\n\nconst useInfiniteQueryDataOptions = <TDataSource extends AnyInfiniteQueryDataSource>(\n    composedOptions: InfiniteQueryObserverExtendedOptions<\n        DataSourceResponse<TDataSource>,\n        DataSourceError<TDataSource>,\n        InfiniteData<DataSourceData<TDataSource>, Partial<DataSourceRequest<TDataSource>>>,\n        DataSourceResponse<TDataSource>,\n        DataSourceKey,\n        Partial<DataSourceRequest<TDataSource>>\n    >,\n): InfiniteQueryObserverOptions<\n    DataSourceResponse<TDataSource>,\n    DataSourceError<TDataSource>,\n    InfiniteData<DataSourceData<TDataSource>, Partial<DataSourceRequest<TDataSource>>>,\n    DataSourceResponse<TDataSource>,\n    DataSourceKey,\n    Partial<DataSourceRequest<TDataSource>>\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 useInfiniteQueryData = <TDataSource extends AnyInfiniteQueryDataSource>(\n    context: DataSourceContext<TDataSource>,\n    dataSource: TDataSource,\n    params: DataSourceParams<TDataSource>,\n    options?: Partial<DataSourceOptions<TDataSource>>,\n): DataSourceState<TDataSource> => {\n    const extendedOptions = composeOptions(context, dataSource, params, options);\n    const composedOptions = useInfiniteQueryDataOptions(extendedOptions);\n    const state = useInfiniteQuery(composedOptions);\n\n    const transformedData = useMemo<DataSourceState<TDataSource>['data']>(\n        () => state.data?.pages.flat(1) ?? [],\n        [state.data],\n    );\n\n    const isDisabled = composedOptions.enabled === false || composedOptions.queryFn === skipToken;\n\n    return {\n        ...state,\n        status: normalizeStatus(state.status, state.fetchStatus),\n        data: transformedData,\n        originalStatus: state.status,\n        originalData: state.data,\n        refetch: isDisabled ? warnDisabledRefetch : wrapRefetch(state.refetch),\n    } as DataSourceState<TDataSource>;\n};\n"],"mappings":";;;AAAA,SAAQA,OAAO,QAAO,OAAO;AAE7B,SAAQC,SAAS,EAAEC,gBAAgB,QAAO,uBAAuB;AAcjE,SAAQC,kBAAkB,QAAO,gCAAgC;AACjE,SAAQC,eAAe,QAAO,6BAA6B;AAC3D,SAAQC,mBAAmB,QAAO,iCAAiC;AACnE,SAAQC,WAAW,QAAO,yBAAyB;AAGnD,SAAQC,cAAc,QAAO,SAAS;AAEtC,IAAMC,2BAA2B,GAAG,SAA9BA,2BAA2BA,CAC7BC,eAOC,EAQA;EACD,IACaC,aAAa,GAGtBD,eAAe,CAHfE,OAAO;IACUC,qBAAqB,GAEtCH,eAAe,CAFfI,eAAe;IACZC,WAAW,GAAAC,wBAAA,CACdN,eAAe,EAAAO,SAAA;EAEnB,IAAAC,mBAAA,GAAmCd,kBAAkB,CAACS,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,oBAAoB,GAAG,SAAvBA,oBAAoBA,CAC7BC,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,2BAA2B,CAACgB,eAAe,CAAC;EACpE,IAAMC,KAAK,GAAGvB,gBAAgB,CAACO,eAAe,CAAC;EAE/C,IAAMiB,eAAe,GAAG1B,OAAO,CAC3B;IAAA,IAAA2B,qBAAA,EAAAC,WAAA;IAAA,QAAAD,qBAAA,IAAAC,WAAA,GAAMH,KAAK,CAACI,IAAI,cAAAD,WAAA,uBAAVA,WAAA,CAAYE,KAAK,CAACC,IAAI,CAAC,CAAC,CAAC,cAAAJ,qBAAA,cAAAA,qBAAA,GAAI,EAAE;EAAA,GACrC,CAACF,KAAK,CAACI,IAAI,CACf,CAAC;EAED,IAAMG,UAAU,GAAGvB,eAAe,CAACwB,OAAO,KAAK,KAAK,IAAIxB,eAAe,CAACE,OAAO,KAAKV,SAAS;EAE7F,OAAAiB,aAAA,CAAAA,aAAA,KACOO,KAAK;IACRS,MAAM,EAAE9B,eAAe,CAACqB,KAAK,CAACS,MAAM,EAAET,KAAK,CAACU,WAAW,CAAC;IACxDN,IAAI,EAAEH,eAAe;IACrBU,cAAc,EAAEX,KAAK,CAACS,MAAM;IAC5BG,YAAY,EAAEZ,KAAK,CAACI,IAAI;IACxBS,OAAO,EAAEN,UAAU,GAAG3B,mBAAmB,GAAGC,WAAW,CAACmB,KAAK,CAACa,OAAO;EAAC;AAE9E,CAAC","ignoreList":[]}

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

@@ -14,6 +14,7 @@ export type AnyPageParam = Partial<any>;
 type ResultWrapper<TResult, TRequest, TResponse, TData, TError> = TResult extends InfiniteQueryObserverResult<InfiniteData<ActualData<TData, TResponse>, Partial<TRequest>>, TError> ? Overwrite<TResult, {
     status: DataLoaderStatus;
     data: Array<FlatArray<Array<ActualData<TData, TResponse>>, 1>>;
+    refetch: () => Promise<void>;
 }> & {
     originalStatus: TResult['status'];
     originalData: TResult['data'];

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

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type {\n    DefaultError,\n    InfiniteData,\n    InfiniteQueryObserverOptions,\n    InfiniteQueryObserverResult,\n    QueryFunctionContext,\n    QueryKey,\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 InfiniteQueryObserverExtendedOptions<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n> = Assign<\n    InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>,\n    QueryDataAdditionalOptions<\n        TQueryFnData,\n        TError,\n        InfiniteData<TQueryData, TPageParam>,\n        TQueryKey\n    >\n>;\n\nexport type InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError> = DataSource<\n    QueryDataSourceContext,\n    TParams,\n    TRequest,\n    TResponse,\n    TData,\n    TError,\n    InfiniteQueryObserverExtendedOptions<\n        NoInfer<TResponse>,\n        NoInfer<TError>,\n        InfiniteData<ActualData<NoInfer<TData>, NoInfer<TResponse>>, Partial<TRequest>>,\n        NoInfer<TResponse>,\n        DataSourceKey,\n        Partial<NoInfer<TRequest>>\n    >,\n    ResultWrapper<\n        InfiniteQueryObserverResult<\n            InfiniteData<ActualData<NoInfer<TData>, NoInfer<TResponse>>, Partial<TRequest>>,\n            NoInfer<TError>\n        >,\n        NoInfer<TRequest>,\n        NoInfer<TResponse>,\n        NoInfer<TData>,\n        NoInfer<TError>\n    >,\n    QueryFunctionContext<DataSourceKey, Partial<NoInfer<TRequest>>>\n> & {\n    type: 'infinite';\n    next: (\n        lastPage: NoInfer<TResponse>,\n        allPages: NoInfer<TResponse>[],\n    ) => Partial<NoInfer<TRequest>> | null | undefined;\n    prev?: (\n        firstPage: NoInfer<TResponse>,\n        allPages: NoInfer<TResponse>[],\n    ) => Partial<NoInfer<TRequest>> | null | undefined;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyInfiniteQueryDataSource = InfiniteQueryDataSource<any, any, any, any, any>;\n\n// It is used instead of `Partial<DataSourceRequest<TDataSource>>` because TS can't calculate type\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyPageParam = Partial<any>;\n\ntype ResultWrapper<TResult, TRequest, TResponse, TData, TError> =\n    TResult extends InfiniteQueryObserverResult<\n        InfiniteData<ActualData<TData, TResponse>, Partial<TRequest>>,\n        TError\n    >\n        ? Overwrite<\n              TResult,\n              {\n                  status: DataLoaderStatus;\n                  data: Array<FlatArray<Array<ActualData<TData, TResponse>>, 1>>;\n              }\n          > & {\n              originalStatus: TResult['status'];\n              originalData: TResult['data'];\n          }\n        : never;\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type {\n    DefaultError,\n    InfiniteData,\n    InfiniteQueryObserverOptions,\n    InfiniteQueryObserverResult,\n    QueryFunctionContext,\n    QueryKey,\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 InfiniteQueryObserverExtendedOptions<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n> = Assign<\n    InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>,\n    QueryDataAdditionalOptions<\n        TQueryFnData,\n        TError,\n        InfiniteData<TQueryData, TPageParam>,\n        TQueryKey\n    >\n>;\n\nexport type InfiniteQueryDataSource<TParams, TRequest, TResponse, TData, TError> = DataSource<\n    QueryDataSourceContext,\n    TParams,\n    TRequest,\n    TResponse,\n    TData,\n    TError,\n    InfiniteQueryObserverExtendedOptions<\n        NoInfer<TResponse>,\n        NoInfer<TError>,\n        InfiniteData<ActualData<NoInfer<TData>, NoInfer<TResponse>>, Partial<TRequest>>,\n        NoInfer<TResponse>,\n        DataSourceKey,\n        Partial<NoInfer<TRequest>>\n    >,\n    ResultWrapper<\n        InfiniteQueryObserverResult<\n            InfiniteData<ActualData<NoInfer<TData>, NoInfer<TResponse>>, Partial<TRequest>>,\n            NoInfer<TError>\n        >,\n        NoInfer<TRequest>,\n        NoInfer<TResponse>,\n        NoInfer<TData>,\n        NoInfer<TError>\n    >,\n    QueryFunctionContext<DataSourceKey, Partial<NoInfer<TRequest>>>\n> & {\n    type: 'infinite';\n    next: (\n        lastPage: NoInfer<TResponse>,\n        allPages: NoInfer<TResponse>[],\n    ) => Partial<NoInfer<TRequest>> | null | undefined;\n    prev?: (\n        firstPage: NoInfer<TResponse>,\n        allPages: NoInfer<TResponse>[],\n    ) => Partial<NoInfer<TRequest>> | null | undefined;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyInfiniteQueryDataSource = InfiniteQueryDataSource<any, any, any, any, any>;\n\n// It is used instead of `Partial<DataSourceRequest<TDataSource>>` because TS can't calculate type\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyPageParam = Partial<any>;\n\ntype ResultWrapper<TResult, TRequest, TResponse, TData, TError> =\n    TResult extends InfiniteQueryObserverResult<\n        InfiniteData<ActualData<TData, TResponse>, Partial<TRequest>>,\n        TError\n    >\n        ? Overwrite<\n              TResult,\n              {\n                  status: DataLoaderStatus;\n                  data: Array<FlatArray<Array<ActualData<TData, TResponse>>, 1>>;\n                  refetch: () => Promise<void>;\n              }\n          > & {\n              originalStatus: TResult['status'];\n              originalData: TResult['data'];\n          }\n        : never;\n"],"mappings":"","ignoreList":[]}

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

@@ -1,9 +1,11 @@
 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 { wrapRefetch } from '../../utils/wrapRefetch';
 import { composeOptions } from './utils';
 var usePlainQueryDataOptions = function usePlainQueryDataOptions(composedOptions) {
   var queryFnOption = composedOptions.queryFn,
@@ -21,9 +23,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 : wrapRefetch(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","wrapRefetch","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';\nimport {wrapRefetch} from '../../utils/wrapRefetch';\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 : wrapRefetch(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;AACnE,SAAQC,WAAW,QAAO,yBAAyB;AAGnD,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,GAAmCd,kBAAkB,CAACS,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,GAAGvB,QAAQ,CAACO,eAAe,CAAC;EAEvC,IAAMiB,UAAU,GAAGjB,eAAe,CAACkB,OAAO,KAAK,KAAK,IAAIlB,eAAe,CAACE,OAAO,KAAKV,SAAS;EAE7F,OAAAiB,aAAA,CAAAA,aAAA,KACOO,KAAK;IACRG,MAAM,EAAExB,eAAe,CAACqB,KAAK,CAACG,MAAM,EAAEH,KAAK,CAACI,WAAW,CAAC;IACxDC,cAAc,EAAEL,KAAK,CAACG,MAAM;IAC5BG,OAAO,EAAEL,UAAU,GAAGrB,mBAAmB,GAAGC,WAAW,CAACmB,KAAK,CAACM,OAAO;EAAC;AAE9E,CAAC","ignoreList":[]}

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

@@ -10,6 +10,7 @@ export type PlainQueryDataSource<TParams, TRequest, TResponse, TData, TError> =
 export type AnyPlainQueryDataSource = PlainQueryDataSource<any, any, any, any, any>;
 type ResultWrapper<TResult, TResponse, TData, TError> = TResult extends QueryObserverResult<ActualData<TData, TResponse>, TError> ? Overwrite<TResult, {
     status: DataLoaderStatus;
+    refetch: () => Promise<void>;
 }> & {
     originalStatus: TResult['status'];
 } : never;

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 {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":[]}
+{"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<\n              TResult,\n              {\n                  status: DataLoaderStatus;\n                  refetch: () => Promise<void>;\n              }\n          > & {originalStatus: TResult['status']}\n        : never;\n"],"mappings":"","ignoreList":[]}

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

@@ -1,3 +1,4 @@
+export * from './components/QueryAsyncBoundary';
 export type { QueryDataSourceContext, AnyQueryDataSource } from './types/base';
 export type { RefetchIntervalFunction, RefetchInterval } from './types/refetch-interval';
 export { useQueryContext } from './hooks/useQueryContext';
@@ -5,6 +6,7 @@ export { useQueryData } from './hooks/useQueryData';
 export { useQueryResponses } from './hooks/useQueryResponses';
 export { useRefetchAll } from './hooks/useRefetchAll';
 export { useRefetchErrored } from './hooks/useRefetchErrored';
+export { useSuspenseQueryData } from './hooks/useSuspenseQueryData';
 export type { InfiniteQueryDataSource, AnyInfiniteQueryDataSource } from './impl/infinite/types';
 export { makeInfiniteQueryDataSource } from './impl/infinite/factory';
 export { composeOptions as composeInfiniteQueryOptions } from './impl/infinite/utils';

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

@@ -1,8 +1,10 @@
+export * from './components/QueryAsyncBoundary';
 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 { useSuspenseQueryData } from './hooks/useSuspenseQueryData';
 export { makeInfiniteQueryDataSource } from './impl/infinite/factory';
 export { composeOptions as composeInfiniteQueryOptions } from './impl/infinite/utils';
 export { makePlainQueryDataSource } from './impl/plain/factory';

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","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":[]}
+{"version":3,"names":["useQueryContext","useQueryData","useQueryResponses","useRefetchAll","useRefetchErrored","useSuspenseQueryData","makeInfiniteQueryDataSource","composeOptions","composeInfiniteQueryOptions","makePlainQueryDataSource","composePlainQueryOptions","normalizeStatus","getProgressiveRefetch","ClientDataManager","DataSourceProvider"],"sources":["index.ts"],"sourcesContent":["export * from './components/QueryAsyncBoundary';\n\nexport 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';\nexport {useSuspenseQueryData} from './hooks/useSuspenseQueryData';\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":"AAAA,cAAc,iCAAiC;AAK/C,SAAQA,eAAe,QAAO,yBAAyB;AACvD,SAAQC,YAAY,QAAO,sBAAsB;AACjD,SAAQC,iBAAiB,QAAO,2BAA2B;AAC3D,SAAQC,aAAa,QAAO,uBAAuB;AACnD,SAAQC,iBAAiB,QAAO,2BAA2B;AAC3D,SAAQC,oBAAoB,QAAO,8BAA8B;AAGjE,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/options.d.ts

@@ -3,6 +3,11 @@ 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 */

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 {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    /** 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":[]}
+{"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/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: () => Promise<void>;

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

@@ -0,0 +1,20 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import { warn } from './warn';
+export var warnDisabledRefetch = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          warn('Disabled refetch is called');
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function warnDisabledRefetch() {
+    return _ref.apply(this, arguments);
+  };
+}();
+// #sourceMappingURL=warnDisabledRefetch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["warn","warnDisabledRefetch","_ref","_asyncToGenerator","_regeneratorRuntime","mark","_callee","wrap","_callee$","_context","prev","next","stop","apply","arguments"],"sources":["warnDisabledRefetch.ts"],"sourcesContent":["import {warn} from './warn';\n\nexport const warnDisabledRefetch = async (): Promise<void> => {\n    warn('Disabled refetch is called');\n};\n"],"mappings":";;AAAA,SAAQA,IAAI,QAAO,QAAQ;AAE3B,OAAO,IAAMC,mBAAmB;EAAA,IAAAC,IAAA,GAAAC,iBAAA,cAAAC,mBAAA,GAAAC,IAAA,CAAG,SAAAC,QAAA;IAAA,OAAAF,mBAAA,GAAAG,IAAA,UAAAC,SAAAC,QAAA;MAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;QAAA;UAC/BX,IAAI,CAAC,4BAA4B,CAAC;QAAC;QAAA;UAAA,OAAAS,QAAA,CAAAG,IAAA;MAAA;IAAA,GAAAN,OAAA;EAAA,CACtC;EAAA,gBAFYL,mBAAmBA,CAAA;IAAA,OAAAC,IAAA,CAAAW,KAAA,OAAAC,SAAA;EAAA;AAAA,GAE/B","ignoreList":[]}

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

@@ -0,0 +1,2 @@
+import type { QueryObserverResult, RefetchOptions } from '@tanstack/react-query';
+export declare function wrapRefetch<TData, TError>(refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<TData, TError>>): (options?: RefetchOptions) => Promise<void>;

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

@@ -0,0 +1,22 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+export function wrapRefetch(refetch) {
+  return /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(options) {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return refetch(options);
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+// #sourceMappingURL=wrapRefetch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["wrapRefetch","refetch","_ref","_asyncToGenerator","_regeneratorRuntime","mark","_callee","options","wrap","_callee$","_context","prev","next","stop","_x","apply","arguments"],"sources":["wrapRefetch.ts"],"sourcesContent":["import type {QueryObserverResult, RefetchOptions} from '@tanstack/react-query';\n\nexport function wrapRefetch<TData, TError>(\n    refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<TData, TError>>,\n): (options?: RefetchOptions) => Promise<void> {\n    return async (options?: RefetchOptions) => {\n        await refetch(options);\n    };\n}\n"],"mappings":";;AAEA,OAAO,SAASA,WAAWA,CACvBC,OAAkF,EACvC;EAC3C;IAAA,IAAAC,IAAA,GAAAC,iBAAA,cAAAC,mBAAA,GAAAC,IAAA,CAAO,SAAAC,QAAOC,OAAwB;MAAA,OAAAH,mBAAA,GAAAI,IAAA,UAAAC,SAAAC,QAAA;QAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;UAAA;YAAAF,QAAA,CAAAE,IAAA;YAAA,OAC5BX,OAAO,CAACM,OAAO,CAAC;UAAA;UAAA;YAAA,OAAAG,QAAA,CAAAG,IAAA;QAAA;MAAA,GAAAP,OAAA;IAAA,CACzB;IAAA,iBAAAQ,EAAA;MAAA,OAAAZ,IAAA,CAAAa,KAAA,OAAAC,SAAA;IAAA;EAAA;AACL","ignoreList":[]}

package/build/plugin/esbuild.d.mts

@@ -0,0 +1,7 @@
+import { r as DataSourceLazyPluginOptions } from "./index-mY40Sgl5.mjs";
+import * as _$esbuild from "esbuild";
+
+//#region src/plugin/esbuild.d.ts
+declare const _default: (options?: DataSourceLazyPluginOptions | undefined) => _$esbuild.Plugin;
+//#endregion
+export { _default as default };

package/build/plugin/esbuild.mjs

@@ -0,0 +1,6 @@
+import { n as dataSourceLazyUnpluginFactory } from "./factory-2tSt4Rte.mjs";
+import { createEsbuildPlugin } from "unplugin";
+//#region src/plugin/esbuild.ts
+var esbuild_default = createEsbuildPlugin(dataSourceLazyUnpluginFactory);
+//#endregion
+export { esbuild_default as default };