@effector-tanstack-query/core 0.1.0

package/dist/createBaseQuery.js

@@ -0,0 +1,204 @@
+import { createStore, createEvent, attach, scopeBind, sample, combine } from 'effector';
+import { $queryClient } from './queryClient.js';
+import { resolveKey, resolveEnabled } from './resolve.js';
+
+// src/createBaseQuery.ts
+var SID_PREFIX = "@tanstack/query-effector";
+var warnedNames = /* @__PURE__ */ new Set();
+function warnMissingName(role) {
+  if (typeof process === "undefined" || process.env.NODE_ENV === "production") {
+    return;
+  }
+  if (warnedNames.has(role)) return;
+  warnedNames.add(role);
+  console.warn(
+    `[@tanstack/query-effector] ${role} created without a "name" \u2014 internal stores will be excluded from serialize(scope). Pass a unique "name" to enable SSR via fork({ values: serialize(scope) }).`
+  );
+}
+function sidConfig(name, role) {
+  if (!name) return {};
+  return {
+    sid: `${SID_PREFIX}.${name}.${role}`,
+    name: `${name}.${role}`
+  };
+}
+function createBaseQuery(explicitClient, options, config) {
+  const { name, reactiveRefetchInterval: $reactiveRefetchInterval } = options;
+  const $resolvedKey = resolveKey(options.queryKey);
+  const $enabled = resolveEnabled(options.enabled);
+  const $effectiveClient = explicitClient ? createStore(explicitClient, {
+    serialize: "ignore"
+  }) : $queryClient;
+  const dataUpdated = createEvent();
+  const errorUpdated = createEvent();
+  const statusUpdated = createEvent();
+  const isFetchingUpdated = createEvent();
+  const fetchStatusUpdated = createEvent();
+  const isPlaceholderDataUpdated = createEvent();
+  const $data = createStore(void 0, {
+    skipVoid: false,
+    ...sidConfig(name, "$data")
+  }).on(dataUpdated, (_, v) => v);
+  const $error = createStore(null, {
+    skipVoid: false,
+    ...sidConfig(name, "$error")
+  }).on(errorUpdated, (_, v) => v);
+  const $status = createStore("pending", {
+    ...sidConfig(name, "$status")
+  }).on(statusUpdated, (_, v) => v);
+  const $isFetching = createStore(false, {
+    ...sidConfig(name, "$isFetching")
+  }).on(isFetchingUpdated, (_, v) => v);
+  const $fetchStatus = createStore("idle", {
+    ...sidConfig(name, "$fetchStatus")
+  }).on(fetchStatusUpdated, (_, v) => v);
+  const $isPlaceholderData = createStore(false, {
+    ...sidConfig(name, "$isPlaceholderData")
+  }).on(isPlaceholderDataUpdated, (_, v) => v);
+  const $isPending = $status.map((s) => s === "pending");
+  const $isSuccess = $status.map((s) => s === "success");
+  const $isError = $status.map((s) => s === "error");
+  const $observer = createStore(null, {
+    serialize: "ignore"
+  });
+  const observerCreated = createEvent();
+  $observer.on(observerCreated, (_, obs) => obs);
+  const observerSubscriptions = /* @__PURE__ */ new WeakMap();
+  const extras = config.setupExtras?.();
+  extras?.setupEffects?.({ $observer });
+  const mountFx = attach({
+    source: { qc: $effectiveClient, observer: $observer },
+    effect: ({ qc, observer: existingObserver }, {
+      key,
+      enabled,
+      refetchInterval
+    }) => {
+      if (!qc) {
+        throw new Error(
+          "[@tanstack/query-effector] No QueryClient is set. Call setQueryClient(qc) before mounting, pass it to fork({ values: [[$queryClient, qc]] }), or pass it explicitly to the factory."
+        );
+      }
+      const observer = existingObserver ?? config.createObserver(qc, { queryKey: key, enabled });
+      const dispatchData = scopeBind(dataUpdated, { safe: true });
+      const dispatchError = scopeBind(errorUpdated, { safe: true });
+      const dispatchStatus = scopeBind(statusUpdated, { safe: true });
+      const dispatchIsFetching = scopeBind(isFetchingUpdated, { safe: true });
+      const dispatchFetchStatus = scopeBind(fetchStatusUpdated, { safe: true });
+      const dispatchIsPlaceholderData = scopeBind(isPlaceholderDataUpdated, {
+        safe: true
+      });
+      const dispatchExtras = extras?.bindDispatcher();
+      observerSubscriptions.get(observer)?.();
+      observer.setOptions({
+        ...observer.options,
+        queryKey: key,
+        enabled,
+        // Only override refetchInterval when the user provided a reactive
+        // Store — otherwise the static value (or function) from the observer
+        // constructor wins.
+        ...$reactiveRefetchInterval ? { refetchInterval } : {}
+      });
+      const dispatch = (result) => {
+        dispatchData(result.data);
+        dispatchError(result.error);
+        dispatchStatus(result.status);
+        dispatchIsFetching(result.isFetching);
+        dispatchFetchStatus(result.fetchStatus);
+        dispatchIsPlaceholderData(result.isPlaceholderData);
+        dispatchExtras?.(result);
+      };
+      const unsubscribe = observer.subscribe(dispatch);
+      observerSubscriptions.set(observer, unsubscribe);
+      dispatch(observer.getCurrentResult());
+      return observer;
+    }
+  });
+  sample({ clock: mountFx.doneData, target: observerCreated });
+  const updateObserverFx = attach({
+    source: $observer,
+    effect: (observer, {
+      key,
+      enabled,
+      refetchInterval
+    }) => {
+      if (!observer) return;
+      const {
+        _defaulted: _d,
+        queryHash: _h,
+        ...baseOptions
+      } = observer.options;
+      observer.setOptions({
+        ...baseOptions,
+        queryKey: key,
+        enabled,
+        ...$reactiveRefetchInterval ? { refetchInterval } : {}
+      });
+    }
+  });
+  const mounted = createEvent();
+  const unmounted = createEvent();
+  const $isMounted = createStore(false, {
+    ...sidConfig(name, "$isMounted")
+  }).on(mounted, () => true).on(unmounted, () => false);
+  const $observerOptions = combine({
+    key: $resolvedKey,
+    enabled: $enabled,
+    refetchInterval: $reactiveRefetchInterval ?? createStore(false)
+  });
+  sample({
+    clock: mounted,
+    source: $observerOptions,
+    target: mountFx
+  });
+  sample({
+    clock: $observerOptions,
+    source: $observerOptions,
+    filter: $isMounted,
+    target: updateObserverFx
+  });
+  const observerDestroyed = createEvent();
+  $observer.on(observerDestroyed, () => null);
+  const unmountFx = attach({
+    source: $observer,
+    effect: (observer) => {
+      if (!observer) return;
+      observerSubscriptions.get(observer)?.();
+      observerSubscriptions.delete(observer);
+      observer.destroy();
+    }
+  });
+  sample({ clock: unmounted, target: unmountFx });
+  sample({ clock: unmountFx.finally, target: observerDestroyed });
+  const refresh = createEvent();
+  const refreshFx = attach({
+    source: { qc: $effectiveClient, key: $resolvedKey },
+    effect: ({ qc, key }) => {
+      if (!qc) return;
+      return qc.invalidateQueries({ queryKey: key });
+    }
+  });
+  sample({ clock: refresh, target: refreshFx });
+  return {
+    $data,
+    $error,
+    $status,
+    $isPending,
+    $isFetching,
+    $isSuccess,
+    $isError,
+    $isPlaceholderData,
+    $fetchStatus,
+    $observer,
+    $queryClient: $effectiveClient,
+    $resolvedKey,
+    $enabled,
+    refresh,
+    mounted,
+    unmounted,
+    ...extras?.stores ?? {}
+  };
+}
+
+export { createBaseQuery, sidConfig, warnMissingName };
+//# sourceMappingURL=createBaseQuery.js.map
+//# sourceMappingURL=createBaseQuery.js.map

package/dist/createBaseQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createBaseQuery.ts"],"names":[],"mappings":"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","file":"createBaseQuery.js","sourcesContent":["import {\n  attach,\n  combine,\n  createEvent,\n  createStore,\n  sample,\n  scopeBind,\n} from 'effector'\nimport type { EventCallable, Store } from 'effector'\nimport type {\n  FetchStatus,\n  QueryClient,\n  QueryKey,\n  QueryStatus,\n} from '@tanstack/query-core'\nimport { $queryClient } from './queryClient'\nimport { resolveEnabled, resolveKey } from './resolve'\nimport type { EffectorQueryKey, StoreOrValue } from './types'\n\n/**\n * The minimal shape of an observer that createBaseQuery knows how to drive.\n * Both QueryObserver and InfiniteQueryObserver satisfy this.\n */\nexport interface BaseObserverLike<TResult> {\n  options: { queryKey: QueryKey; _defaulted?: boolean; queryHash?: string }\n  setOptions(options: any): void\n  subscribe(listener: (result: TResult) => void): () => void\n  getCurrentResult(): TResult\n  destroy(): void\n}\n\n/**\n * The subset of observer result fields that createBaseQuery wires up\n * into stores common to all query flavors.\n */\nexport interface BaseObserverResult<TData, TError> {\n  data: TData | undefined\n  error: TError | null\n  status: QueryStatus\n  isFetching: boolean\n  fetchStatus: FetchStatus\n  isPlaceholderData: boolean\n}\n\nexport interface BaseQueryStores<TData, TError, TObserver> {\n  $data: Store<TData | undefined>\n  $error: Store<TError | null>\n  $status: Store<QueryStatus>\n  $isPending: Store<boolean>\n  $isFetching: Store<boolean>\n  $isSuccess: Store<boolean>\n  $isError: Store<boolean>\n  $isPlaceholderData: Store<boolean>\n  $fetchStatus: Store<FetchStatus>\n  /**\n   * Per-scope observer. Populated on first `mounted()` via attach over\n   * `$queryClient` — every fork scope has its own Observer instance bound\n   * to the scope's QueryClient. Read scope-aware via `useUnit($observer)`.\n   */\n  $observer: Store<TObserver | null>\n  /**\n   * Resolved QueryClient store. If the factory was called with an explicit\n   * client, this is a frozen store of that client. Otherwise it's the global\n   * `$queryClient`, which honors `fork({ values })` overrides.\n   */\n  $queryClient: Store<QueryClient | null>\n  /** Internal — used by the React suspense hooks. */\n  $resolvedKey: Store<QueryKey>\n  /** Internal — used by the React suspense hooks. */\n  $enabled: Store<boolean>\n  refresh: EventCallable<void>\n  mounted: EventCallable<void>\n  unmounted: EventCallable<void>\n}\n\nexport interface BaseQueryOptions {\n  queryKey: EffectorQueryKey\n  enabled?: StoreOrValue<boolean>\n  /**\n   * Pre-resolved reactive `refetchInterval`. The per-flavor factory extracts\n   * the original option, and — if it's a Store — passes the Store here while\n   * stripping the value from the observer constructor options. Static values\n   * and function forms continue to flow through `restOptions` to the\n   * observer.\n   */\n  reactiveRefetchInterval?: Store<number | false | undefined>\n  name?: string\n}\n\nconst SID_PREFIX = '@tanstack/query-effector'\n\nconst warnedNames = new Set<string>()\n\nexport function warnMissingName(role: string): void {\n  if (typeof process === 'undefined' || process.env.NODE_ENV === 'production') {\n    return\n  }\n  if (warnedNames.has(role)) return\n  warnedNames.add(role)\n  // eslint-disable-next-line no-console\n  console.warn(\n    `[@tanstack/query-effector] ${role} created without a \"name\" — internal stores will be excluded from serialize(scope). ` +\n      `Pass a unique \"name\" to enable SSR via fork({ values: serialize(scope) }).`,\n  )\n}\n\nexport function sidConfig(\n  name: string | undefined,\n  role: string,\n): { sid: string; name: string } | {} {\n  if (!name) return {}\n  return {\n    sid: `${SID_PREFIX}.${name}.${role}`,\n    name: `${name}.${role}`,\n  }\n}\n\nexport interface ExtrasSetup<TResult, TObserver, TExtraStores> {\n  /** Extra stores/events merged into the final result object. */\n  stores: TExtraStores\n  /**\n   * Invoked inside the mount effect. Must scope-bind any extra events\n   * and return a function that dispatches extra fields from the observer\n   * result. The returned dispatcher is called on every subscription\n   * notification alongside the base dispatcher.\n   */\n  bindDispatcher: () => (result: TResult) => void\n  /**\n   * Lets a flavor wire its own per-observer effects (e.g.\n   * fetchNextPage / fetchPreviousPage for infinite queries). Receives the\n   * per-scope `$observer` store so the flavor can build attach-based\n   * effects that resolve the observer from the current scope.\n   */\n  setupEffects?: (params: { $observer: Store<TObserver | null> }) => void\n}\n\nexport interface CreateBaseQueryConfig<\n  TData,\n  TError,\n  TResult extends BaseObserverResult<TData, TError>,\n  TObserver extends BaseObserverLike<TResult>,\n  TExtraStores,\n> {\n  /** Build the observer for the current scope. Receives the resolved client. */\n  createObserver: (\n    queryClient: QueryClient,\n    initial: { queryKey: QueryKey; enabled: boolean },\n  ) => TObserver\n  /**\n   * Hook for query flavors that need additional stores/events (e.g. infinite\n   * query's hasNextPage, fetchNextPage). Called once at factory time.\n   */\n  setupExtras?: () => ExtrasSetup<TResult, TObserver, TExtraStores>\n}\n\nexport function createBaseQuery<\n  TData,\n  TError,\n  TResult extends BaseObserverResult<TData, TError>,\n  TObserver extends BaseObserverLike<TResult>,\n  TExtraStores = {},\n>(\n  explicitClient: QueryClient | null,\n  options: BaseQueryOptions,\n  config: CreateBaseQueryConfig<TData, TError, TResult, TObserver, TExtraStores>,\n): BaseQueryStores<TData, TError, TObserver> & TExtraStores {\n  const { name, reactiveRefetchInterval: $reactiveRefetchInterval } = options\n  const $resolvedKey = resolveKey(options.queryKey)\n  const $enabled = resolveEnabled(options.enabled)\n\n  // If an explicit client is passed, the factory is locked to it. fork()\n  // values cannot override the captured value because $effectiveClient is a\n  // brand-new store (not the global one). When no explicit client is passed,\n  // we route through $queryClient — which respects fork({ values }) for\n  // per-scope isolation.\n  const $effectiveClient: Store<QueryClient | null> = explicitClient\n    ? createStore(explicitClient as QueryClient | null, {\n        serialize: 'ignore',\n      })\n    : $queryClient\n\n  const dataUpdated = createEvent<TData | undefined>()\n  const errorUpdated = createEvent<TError | null>()\n  const statusUpdated = createEvent<QueryStatus>()\n  const isFetchingUpdated = createEvent<boolean>()\n  const fetchStatusUpdated = createEvent<FetchStatus>()\n  const isPlaceholderDataUpdated = createEvent<boolean>()\n\n  const $data = createStore<TData | undefined>(undefined, {\n    skipVoid: false,\n    ...sidConfig(name, '$data'),\n  }).on(dataUpdated, (_, v) => v)\n  const $error = createStore<TError | null>(null, {\n    skipVoid: false,\n    ...sidConfig(name, '$error'),\n  }).on(errorUpdated, (_, v) => v)\n  const $status = createStore<QueryStatus>('pending', {\n    ...sidConfig(name, '$status'),\n  }).on(statusUpdated, (_, v) => v)\n  const $isFetching = createStore(false, {\n    ...sidConfig(name, '$isFetching'),\n  }).on(isFetchingUpdated, (_, v) => v)\n  const $fetchStatus = createStore<FetchStatus>('idle', {\n    ...sidConfig(name, '$fetchStatus'),\n  }).on(fetchStatusUpdated, (_, v) => v)\n  const $isPlaceholderData = createStore(false, {\n    ...sidConfig(name, '$isPlaceholderData'),\n  }).on(isPlaceholderDataUpdated, (_, v) => v)\n\n  // Derived stores via .map don't accept sid in their config — effector's\n  // serialize() captures source-store values, and derived stores recompute\n  // automatically on the client after fork({ values }).\n  const $isPending = $status.map((s) => s === 'pending')\n  const $isSuccess = $status.map((s) => s === 'success')\n  const $isError = $status.map((s) => s === 'error')\n\n  // Per-scope observer storage. Carries runtime-only references\n  // (subscriptions, callbacks) — must never participate in serialization.\n  const $observer = createStore<TObserver | null>(null, {\n    serialize: 'ignore',\n  })\n  const observerCreated = createEvent<TObserver>()\n  $observer.on(observerCreated, (_, obs) => obs)\n\n  // Per-observer unsubscribe handles. WeakMap so abandoned observers (e.g.\n  // a scope that was discarded without unmount) are GC'able.\n  const observerSubscriptions = new WeakMap<TObserver, () => void>()\n\n  const extras = config.setupExtras?.()\n  extras?.setupEffects?.({ $observer })\n\n  // Runs once per mount. Creates the observer for the current scope (if not\n  // yet created) and attaches the subscription. scopeBind({ safe: true })\n  // reliably captures the fork scope here because this effect is triggered\n  // directly from allSettled(mounted). Bound dispatchers are captured in the\n  // observer callback's closure and reused for all subsequent notifications\n  // (including after key/enabled changes).\n  const mountFx = attach({\n    source: { qc: $effectiveClient, observer: $observer },\n    effect: (\n      { qc, observer: existingObserver },\n      {\n        key,\n        enabled,\n        refetchInterval,\n      }: {\n        key: QueryKey\n        enabled: boolean\n        refetchInterval: number | false | undefined\n      },\n    ) => {\n      if (!qc) {\n        throw new Error(\n          '[@tanstack/query-effector] No QueryClient is set. Call setQueryClient(qc) before mounting, ' +\n            'pass it to fork({ values: [[$queryClient, qc]] }), or pass it explicitly to the factory.',\n        )\n      }\n\n      const observer =\n        existingObserver ??\n        config.createObserver(qc, { queryKey: key, enabled })\n\n      const dispatchData = scopeBind(dataUpdated, { safe: true })\n      const dispatchError = scopeBind(errorUpdated, { safe: true })\n      const dispatchStatus = scopeBind(statusUpdated, { safe: true })\n      const dispatchIsFetching = scopeBind(isFetchingUpdated, { safe: true })\n      const dispatchFetchStatus = scopeBind(fetchStatusUpdated, { safe: true })\n      const dispatchIsPlaceholderData = scopeBind(isPlaceholderDataUpdated, {\n        safe: true,\n      })\n      const dispatchExtras = extras?.bindDispatcher()\n\n      observerSubscriptions.get(observer)?.()\n      observer.setOptions({\n        ...observer.options,\n        queryKey: key,\n        enabled,\n        // Only override refetchInterval when the user provided a reactive\n        // Store — otherwise the static value (or function) from the observer\n        // constructor wins.\n        ...($reactiveRefetchInterval ? { refetchInterval } : {}),\n      })\n\n      const dispatch = (result: TResult) => {\n        dispatchData(result.data)\n        dispatchError(result.error)\n        dispatchStatus(result.status)\n        dispatchIsFetching(result.isFetching)\n        dispatchFetchStatus(result.fetchStatus)\n        dispatchIsPlaceholderData(result.isPlaceholderData)\n        dispatchExtras?.(result)\n      }\n\n      const unsubscribe = observer.subscribe(dispatch)\n      observerSubscriptions.set(observer, unsubscribe)\n\n      // Emit the current state immediately — observer.subscribe() may not\n      // fire the callback synchronously when cached data already matches\n      // the observer's initial result (e.g. staleTime + setQueryData).\n      // This mirrors react-query's getOptimisticResult() on mount.\n      dispatch(observer.getCurrentResult())\n\n      return observer\n    },\n  })\n\n  sample({ clock: mountFx.doneData, target: observerCreated })\n\n  // Runs when key / enabled / reactive refetchInterval change after mount.\n  // Only updates observer options — subscription + dispatchers were already\n  // wired in mountFx.\n  const updateObserverFx = attach({\n    source: $observer,\n    effect: (\n      observer,\n      {\n        key,\n        enabled,\n        refetchInterval,\n      }: {\n        key: QueryKey\n        enabled: boolean\n        refetchInterval: number | false | undefined\n      },\n    ) => {\n      if (!observer) return\n      // Strip _defaulted and queryHash so defaultQueryOptions() recomputes\n      // the hash for the new key. Without this, the old hash is preserved and\n      // QueryObserver#updateQuery() finds the old query — no key switch, no fetch.\n      const {\n        _defaulted: _d,\n        queryHash: _h,\n        ...baseOptions\n      } = observer.options as typeof observer.options & {\n        _defaulted?: boolean\n        queryHash?: string\n      }\n      observer.setOptions({\n        ...baseOptions,\n        queryKey: key,\n        enabled,\n        ...($reactiveRefetchInterval ? { refetchInterval } : {}),\n      })\n    },\n  })\n\n  const mounted = createEvent<void>()\n  const unmounted = createEvent<void>()\n  const $isMounted = createStore(false, {\n    ...sidConfig(name, '$isMounted'),\n  })\n    .on(mounted, () => true)\n    .on(unmounted, () => false)\n\n  // Combine of all reactive options that drive observer.setOptions. Built once\n  // so mountFx and updateObserverFx see the same shape. When the user didn't\n  // pass a reactive `refetchInterval`, we fall back to a static-`false` store\n  // (its emitted value is never read — the spread is guarded by the original\n  // `$reactiveRefetchInterval` reference).\n  const $observerOptions = combine({\n    key: $resolvedKey,\n    enabled: $enabled,\n    refetchInterval:\n      $reactiveRefetchInterval ??\n      createStore<number | false | undefined>(false),\n  })\n\n  sample({\n    clock: mounted,\n    source: $observerOptions,\n    target: mountFx,\n  })\n\n  sample({\n    clock: $observerOptions,\n    source: $observerOptions,\n    filter: $isMounted,\n    target: updateObserverFx,\n  })\n\n  // Single effect: tear down subscription + destroy + clear $observer.\n  // Doing all three in one effect avoids ordering ambiguity vs. separate\n  // events that all sample from `unmounted`.\n  const observerDestroyed = createEvent<void>()\n  $observer.on(observerDestroyed, () => null)\n\n  const unmountFx = attach({\n    source: $observer,\n    effect: (observer) => {\n      if (!observer) return\n      observerSubscriptions.get(observer)?.()\n      observerSubscriptions.delete(observer)\n      observer.destroy()\n    },\n  })\n  sample({ clock: unmounted, target: unmountFx })\n  sample({ clock: unmountFx.finally, target: observerDestroyed })\n\n  const refresh = createEvent<void>()\n  const refreshFx = attach({\n    source: { qc: $effectiveClient, key: $resolvedKey },\n    effect: ({ qc, key }) => {\n      if (!qc) return\n      return qc.invalidateQueries({ queryKey: key })\n    },\n  })\n  sample({ clock: refresh, target: refreshFx })\n\n  return {\n    $data,\n    $error,\n    $status,\n    $isPending,\n    $isFetching,\n    $isSuccess,\n    $isError,\n    $isPlaceholderData,\n    $fetchStatus,\n    $observer,\n    $queryClient: $effectiveClient,\n    $resolvedKey,\n    $enabled,\n    refresh,\n    mounted,\n    unmounted,\n    ...(extras?.stores ?? ({} as TExtraStores)),\n  }\n}\n"]}

package/dist/createInfiniteQuery.cjs

@@ -0,0 +1,193 @@
+'use strict';
+
+var effector = require('effector');
+var queryCore = require('@tanstack/query-core');
+var createBaseQuery_cjs = require('./createBaseQuery.cjs');
+var resolve_cjs = require('./resolve.cjs');
+
+// src/createInfiniteQuery.ts
+function createInfiniteQuery(arg1, arg2) {
+  const [explicitClient, options] = parseInfiniteArgs(arg1, arg2);
+  const { queryKey, enabled, name, ...restOptions } = options;
+  if (!name) createBaseQuery_cjs.warnMissingName("createInfiniteQuery");
+  const reactiveRefetchInterval = resolve_cjs.resolveReactiveRefetchInterval(
+    restOptions.refetchInterval
+  );
+  if (reactiveRefetchInterval) {
+    delete restOptions.refetchInterval;
+  }
+  const base = createBaseQuery_cjs.createBaseQuery(
+    explicitClient,
+    { queryKey, enabled, name, reactiveRefetchInterval },
+    {
+      createObserver: (qc, { queryKey: key, enabled: isEnabled }) => new queryCore.InfiniteQueryObserver(qc, {
+        ...restOptions,
+        queryKey: key,
+        enabled: isEnabled
+      }),
+      setupExtras: () => {
+        const hasNextPageUpdated = effector.createEvent();
+        const hasPreviousPageUpdated = effector.createEvent();
+        const isFetchingNextPageUpdated = effector.createEvent();
+        const isFetchingPreviousPageUpdated = effector.createEvent();
+        const isFetchNextPageErrorUpdated = effector.createEvent();
+        const isFetchPreviousPageErrorUpdated = effector.createEvent();
+        const $hasNextPage = effector.createStore(false, {
+          ...createBaseQuery_cjs.sidConfig(name, "$hasNextPage")
+        }).on(hasNextPageUpdated, (_, v) => v);
+        const $hasPreviousPage = effector.createStore(false, {
+          ...createBaseQuery_cjs.sidConfig(name, "$hasPreviousPage")
+        }).on(hasPreviousPageUpdated, (_, v) => v);
+        const $isFetchingNextPage = effector.createStore(false, {
+          ...createBaseQuery_cjs.sidConfig(name, "$isFetchingNextPage")
+        }).on(isFetchingNextPageUpdated, (_, v) => v);
+        const $isFetchingPreviousPage = effector.createStore(false, {
+          ...createBaseQuery_cjs.sidConfig(name, "$isFetchingPreviousPage")
+        }).on(isFetchingPreviousPageUpdated, (_, v) => v);
+        const $isFetchNextPageError = effector.createStore(false, {
+          ...createBaseQuery_cjs.sidConfig(name, "$isFetchNextPageError")
+        }).on(isFetchNextPageErrorUpdated, (_, v) => v);
+        const $isFetchPreviousPageError = effector.createStore(false, {
+          ...createBaseQuery_cjs.sidConfig(name, "$isFetchPreviousPageError")
+        }).on(isFetchPreviousPageErrorUpdated, (_, v) => v);
+        const fetchNextPage = effector.createEvent();
+        const fetchPreviousPage = effector.createEvent();
+        return {
+          stores: {
+            $hasNextPage,
+            $hasPreviousPage,
+            $isFetchingNextPage,
+            $isFetchingPreviousPage,
+            $isFetchNextPageError,
+            $isFetchPreviousPageError,
+            fetchNextPage,
+            fetchPreviousPage
+          },
+          // Wire fetchNextPage / fetchPreviousPage as scope-aware effects via
+          // attach over $observer — same pattern as the rest of createBaseQuery.
+          setupEffects: ({ $observer }) => {
+            const fetchNextPageFx = effector.attach({
+              source: $observer,
+              effect: (observer) => {
+                if (!observer) return;
+                observer.fetchNextPage();
+              }
+            });
+            effector.sample({ clock: fetchNextPage, target: fetchNextPageFx });
+            const fetchPreviousPageFx = effector.attach({
+              source: $observer,
+              effect: (observer) => {
+                if (!observer) return;
+                observer.fetchPreviousPage();
+              }
+            });
+            effector.sample({ clock: fetchPreviousPage, target: fetchPreviousPageFx });
+          },
+          bindDispatcher: () => {
+            const dispatchHasNextPage = effector.scopeBind(hasNextPageUpdated, {
+              safe: true
+            });
+            const dispatchHasPreviousPage = effector.scopeBind(hasPreviousPageUpdated, {
+              safe: true
+            });
+            const dispatchIsFetchingNextPage = effector.scopeBind(
+              isFetchingNextPageUpdated,
+              { safe: true }
+            );
+            const dispatchIsFetchingPreviousPage = effector.scopeBind(
+              isFetchingPreviousPageUpdated,
+              { safe: true }
+            );
+            const dispatchIsFetchNextPageError = effector.scopeBind(
+              isFetchNextPageErrorUpdated,
+              { safe: true }
+            );
+            const dispatchIsFetchPreviousPageError = effector.scopeBind(
+              isFetchPreviousPageErrorUpdated,
+              { safe: true }
+            );
+            return (result2) => {
+              dispatchHasNextPage(result2.hasNextPage);
+              dispatchHasPreviousPage(result2.hasPreviousPage);
+              dispatchIsFetchingNextPage(result2.isFetchingNextPage);
+              dispatchIsFetchingPreviousPage(result2.isFetchingPreviousPage);
+              dispatchIsFetchNextPageError(result2.isFetchNextPageError);
+              dispatchIsFetchPreviousPageError(result2.isFetchPreviousPageError);
+            };
+          }
+        };
+      }
+    }
+  );
+  const prefetch = effector.createEvent();
+  const prefetchFx = effector.attach({
+    source: {
+      qc: base.$queryClient,
+      key: base.$resolvedKey,
+      enabled: base.$enabled
+    },
+    effect: ({ qc, key, enabled: enabled2 }) => {
+      if (!qc || !enabled2) return;
+      return qc.fetchInfiniteQuery({
+        ...restOptions,
+        queryKey: key
+      });
+    }
+  });
+  effector.sample({ clock: prefetch, target: prefetchFx });
+  const result = {
+    $data: base.$data,
+    $error: base.$error,
+    $status: base.$status,
+    $isPending: base.$isPending,
+    $isFetching: base.$isFetching,
+    $isSuccess: base.$isSuccess,
+    $isError: base.$isError,
+    $isPlaceholderData: base.$isPlaceholderData,
+    $fetchStatus: base.$fetchStatus,
+    $hasNextPage: base.$hasNextPage,
+    $hasPreviousPage: base.$hasPreviousPage,
+    $isFetchingNextPage: base.$isFetchingNextPage,
+    $isFetchingPreviousPage: base.$isFetchingPreviousPage,
+    $isFetchNextPageError: base.$isFetchNextPageError,
+    $isFetchPreviousPageError: base.$isFetchPreviousPageError,
+    $observer: base.$observer,
+    $queryClient: base.$queryClient,
+    fetchNextPage: base.fetchNextPage,
+    fetchPreviousPage: base.fetchPreviousPage,
+    refresh: base.refresh,
+    prefetch,
+    mounted: base.mounted,
+    unmounted: base.unmounted
+  };
+  Object.defineProperty(result, "__createObserver", {
+    enumerable: false,
+    value: (qc, init) => new queryCore.InfiniteQueryObserver(qc, {
+      ...restOptions,
+      queryKey: init.queryKey,
+      enabled: init.enabled
+    })
+  });
+  Object.defineProperty(result, "__resolvedKey", {
+    enumerable: false,
+    value: base.$resolvedKey
+  });
+  Object.defineProperty(result, "__enabled", {
+    enumerable: false,
+    value: base.$enabled
+  });
+  return result;
+}
+function parseInfiniteArgs(arg1, arg2) {
+  if (arg2 !== void 0) {
+    return [arg1, arg2];
+  }
+  return [
+    null,
+    arg1
+  ];
+}
+
+exports.createInfiniteQuery = createInfiniteQuery;
+//# sourceMappingURL=createInfiniteQuery.cjs.map
+//# sourceMappingURL=createInfiniteQuery.cjs.map

package/dist/createInfiniteQuery.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createInfiniteQuery.ts"],"names":["warnMissingName","resolveReactiveRefetchInterval","createBaseQuery","InfiniteQueryObserver","createEvent","createStore","sidConfig","attach","sample","scopeBind","result","enabled"],"mappings":";;;;;;;;AA2CO,SAAS,mBAAA,CAMd,MAGA,IAAA,EACgD;AAChD,EAAA,MAAM,CAAC,cAAA,EAAgB,OAAO,CAAA,GAAI,iBAAA,CAKhC,MAAM,IAAI,CAAA;AACZ,EAAA,MAAM,EAAE,QAAA,EAAU,OAAA,EAAS,IAAA,EAAM,GAAG,aAAY,GAAI,OAAA;AAEpD,EAAA,IAAI,CAAC,IAAA,EAAMA,mCAAA,CAAgB,qBAAqB,CAAA;AAEhD,EAAA,MAAM,uBAAA,GAA0BC,0CAAA;AAAA,IAC7B,WAAA,CAA8C;AAAA,GACjD;AACA,EAAA,IAAI,uBAAA,EAAyB;AAC3B,IAAA,OAAQ,WAAA,CAA8C,eAAA;AAAA,EACxD;AAEA,EAAA,MAAM,IAAA,GAAOC,mCAAA;AAAA,IAgBX,cAAA;AAAA,IACA,EAAE,QAAA,EAAU,OAAA,EAAS,IAAA,EAAM,uBAAA,EAAwB;AAAA,IACnD;AAAA,MACE,cAAA,EAAgB,CAAC,EAAA,EAAI,EAAE,QAAA,EAAU,GAAA,EAAK,OAAA,EAAS,SAAA,EAAU,KACvD,IAAIC,+BAAA,CAMF,EAAA,EAAI;AAAA,QACJ,GAAG,WAAA;AAAA,QACH,QAAA,EAAU,GAAA;AAAA,QACV,OAAA,EAAS;AAAA,OACH,CAAA;AAAA,MACV,aAAa,MAAM;AACjB,QAAA,MAAM,qBAAqBC,oBAAA,EAAqB;AAChD,QAAA,MAAM,yBAAyBA,oBAAA,EAAqB;AACpD,QAAA,MAAM,4BAA4BA,oBAAA,EAAqB;AACvD,QAAA,MAAM,gCAAgCA,oBAAA,EAAqB;AAC3D,QAAA,MAAM,8BAA8BA,oBAAA,EAAqB;AACzD,QAAA,MAAM,kCAAkCA,oBAAA,EAAqB;AAE7D,QAAA,MAAM,YAAA,GAAeC,qBAAY,KAAA,EAAO;AAAA,UACtC,GAAGC,6BAAA,CAAU,IAAA,EAAM,cAAc;AAAA,SAClC,CAAA,CAAE,EAAA,CAAG,oBAAoB,CAAC,CAAA,EAAG,MAAM,CAAC,CAAA;AACrC,QAAA,MAAM,gBAAA,GAAmBD,qBAAY,KAAA,EAAO;AAAA,UAC1C,GAAGC,6BAAA,CAAU,IAAA,EAAM,kBAAkB;AAAA,SACtC,CAAA,CAAE,EAAA,CAAG,wBAAwB,CAAC,CAAA,EAAG,MAAM,CAAC,CAAA;AACzC,QAAA,MAAM,mBAAA,GAAsBD,qBAAY,KAAA,EAAO;AAAA,UAC7C,GAAGC,6BAAA,CAAU,IAAA,EAAM,qBAAqB;AAAA,SACzC,CAAA,CAAE,EAAA,CAAG,2BAA2B,CAAC,CAAA,EAAG,MAAM,CAAC,CAAA;AAC5C,QAAA,MAAM,uBAAA,GAA0BD,qBAAY,KAAA,EAAO;AAAA,UACjD,GAAGC,6BAAA,CAAU,IAAA,EAAM,yBAAyB;AAAA,SAC7C,CAAA,CAAE,EAAA,CAAG,+BAA+B,CAAC,CAAA,EAAG,MAAM,CAAC,CAAA;AAChD,QAAA,MAAM,qBAAA,GAAwBD,qBAAY,KAAA,EAAO;AAAA,UAC/C,GAAGC,6BAAA,CAAU,IAAA,EAAM,uBAAuB;AAAA,SAC3C,CAAA,CAAE,EAAA,CAAG,6BAA6B,CAAC,CAAA,EAAG,MAAM,CAAC,CAAA;AAC9C,QAAA,MAAM,yBAAA,GAA4BD,qBAAY,KAAA,EAAO;AAAA,UACnD,GAAGC,6BAAA,CAAU,IAAA,EAAM,2BAA2B;AAAA,SAC/C,CAAA,CAAE,EAAA,CAAG,iCAAiC,CAAC,CAAA,EAAG,MAAM,CAAC,CAAA;AAElD,QAAA,MAAM,gBAAgBF,oBAAA,EAAkB;AACxC,QAAA,MAAM,oBAAoBA,oBAAA,EAAkB;AAE5C,QAAA,OAAO;AAAA,UACL,MAAA,EAAQ;AAAA,YACN,YAAA;AAAA,YACA,gBAAA;AAAA,YACA,mBAAA;AAAA,YACA,uBAAA;AAAA,YACA,qBAAA;AAAA,YACA,yBAAA;AAAA,YACA,aAAA;AAAA,YACA;AAAA,WACF;AAAA;AAAA;AAAA,UAGA,YAAA,EAAc,CAAC,EAAE,SAAA,EAAU,KAAM;AAC/B,YAAA,MAAM,kBAAkBG,eAAA,CAAO;AAAA,cAC7B,MAAA,EAAQ,SAAA;AAAA,cACR,MAAA,EAAQ,CAAC,QAAA,KAAa;AACpB,gBAAA,IAAI,CAAC,QAAA,EAAU;AACf,gBAAA,QAAA,CAAS,aAAA,EAAc;AAAA,cACzB;AAAA,aACD,CAAA;AACD,YAAAC,eAAA,CAAO,EAAE,KAAA,EAAO,aAAA,EAAe,MAAA,EAAQ,iBAAiB,CAAA;AAExD,YAAA,MAAM,sBAAsBD,eAAA,CAAO;AAAA,cACjC,MAAA,EAAQ,SAAA;AAAA,cACR,MAAA,EAAQ,CAAC,QAAA,KAAa;AACpB,gBAAA,IAAI,CAAC,QAAA,EAAU;AACf,gBAAA,QAAA,CAAS,iBAAA,EAAkB;AAAA,cAC7B;AAAA,aACD,CAAA;AACD,YAAAC,eAAA,CAAO,EAAE,KAAA,EAAO,iBAAA,EAAmB,MAAA,EAAQ,qBAAqB,CAAA;AAAA,UAClE,CAAA;AAAA,UACA,gBAAgB,MAAM;AACpB,YAAA,MAAM,mBAAA,GAAsBC,mBAAU,kBAAA,EAAoB;AAAA,cACxD,IAAA,EAAM;AAAA,aACP,CAAA;AACD,YAAA,MAAM,uBAAA,GAA0BA,mBAAU,sBAAA,EAAwB;AAAA,cAChE,IAAA,EAAM;AAAA,aACP,CAAA;AACD,YAAA,MAAM,0BAAA,GAA6BA,kBAAA;AAAA,cACjC,yBAAA;AAAA,cACA,EAAE,MAAM,IAAA;AAAK,aACf;AACA,YAAA,MAAM,8BAAA,GAAiCA,kBAAA;AAAA,cACrC,6BAAA;AAAA,cACA,EAAE,MAAM,IAAA;AAAK,aACf;AACA,YAAA,MAAM,4BAAA,GAA+BA,kBAAA;AAAA,cACnC,2BAAA;AAAA,cACA,EAAE,MAAM,IAAA;AAAK,aACf;AACA,YAAA,MAAM,gCAAA,GAAmCA,kBAAA;AAAA,cACvC,+BAAA;AAAA,cACA,EAAE,MAAM,IAAA;AAAK,aACf;AAEA,YAAA,OAAO,CAACC,OAAAA,KAAW;AACjB,cAAA,mBAAA,CAAoBA,QAAO,WAAW,CAAA;AACtC,cAAA,uBAAA,CAAwBA,QAAO,eAAe,CAAA;AAC9C,cAAA,0BAAA,CAA2BA,QAAO,kBAAkB,CAAA;AACpD,cAAA,8BAAA,CAA+BA,QAAO,sBAAsB,CAAA;AAC5D,cAAA,4BAAA,CAA6BA,QAAO,oBAAoB,CAAA;AACxD,cAAA,gCAAA,CAAiCA,QAAO,wBAAwB,CAAA;AAAA,YAClE,CAAA;AAAA,UACF;AAAA,SACF;AAAA,MACF;AAAA;AACF,GACF;AAIA,EAAA,MAAM,WAAWN,oBAAA,EAAkB;AACnC,EAAA,MAAM,aAAaG,eAAA,CAAO;AAAA,IACxB,MAAA,EAAQ;AAAA,MACN,IAAI,IAAA,CAAK,YAAA;AAAA,MACT,KAAK,IAAA,CAAK,YAAA;AAAA,MACV,SAAS,IAAA,CAAK;AAAA,KAChB;AAAA,IACA,QAAQ,CAAC,EAAE,IAAI,GAAA,EAAK,OAAA,EAAAI,UAAQ,KAAM;AAChC,MAAA,IAAI,CAAC,EAAA,IAAM,CAACA,QAAAA,EAAS;AACrB,MAAA,OAAO,GAAG,kBAAA,CAAmB;AAAA,QAC3B,GAAG,WAAA;AAAA,QACH,QAAA,EAAU;AAAA,OACJ,CAAA;AAAA,IACV;AAAA,GACD,CAAA;AACD,EAAAH,eAAA,CAAO,EAAE,KAAA,EAAO,QAAA,EAAU,MAAA,EAAQ,YAAY,CAAA;AAE9C,EAAA,MAAM,MAAA,GAAyD;AAAA,IAC7D,OAAO,IAAA,CAAK,KAAA;AAAA,IACZ,QAAQ,IAAA,CAAK,MAAA;AAAA,IACb,SAAS,IAAA,CAAK,OAAA;AAAA,IACd,YAAY,IAAA,CAAK,UAAA;AAAA,IACjB,aAAa,IAAA,CAAK,WAAA;AAAA,IAClB,YAAY,IAAA,CAAK,UAAA;AAAA,IACjB,UAAU,IAAA,CAAK,QAAA;AAAA,IACf,oBAAoB,IAAA,CAAK,kBAAA;AAAA,IACzB,cAAc,IAAA,CAAK,YAAA;AAAA,IACnB,cAAc,IAAA,CAAK,YAAA;AAAA,IACnB,kBAAkB,IAAA,CAAK,gBAAA;AAAA,IACvB,qBAAqB,IAAA,CAAK,mBAAA;AAAA,IAC1B,yBAAyB,IAAA,CAAK,uBAAA;AAAA,IAC9B,uBAAuB,IAAA,CAAK,qBAAA;AAAA,IAC5B,2BAA2B,IAAA,CAAK,yBAAA;AAAA,IAChC,WAAW,IAAA,CAAK,SAAA;AAAA,IAChB,cAAc,IAAA,CAAK,YAAA;AAAA,IACnB,eAAe,IAAA,CAAK,aAAA;AAAA,IACpB,mBAAmB,IAAA,CAAK,iBAAA;AAAA,IACxB,SAAS,IAAA,CAAK,OAAA;AAAA,IACd,QAAA;AAAA,IACA,SAAS,IAAA,CAAK,OAAA;AAAA,IACd,WAAW,IAAA,CAAK;AAAA,GAClB;AAEA,EAAA,MAAA,CAAO,cAAA,CAAe,QAAQ,kBAAA,EAAoB;AAAA,IAChD,UAAA,EAAY,KAAA;AAAA,IACZ,OAAO,CAAC,EAAA,EAAiB,IAAA,KACvB,IAAIL,gCAMF,EAAA,EAAI;AAAA,MACJ,GAAG,WAAA;AAAA,MACH,UAAU,IAAA,CAAK,QAAA;AAAA,MACf,SAAS,IAAA,CAAK;AAAA,KACR;AAAA,GACX,CAAA;AACD,EAAA,MAAA,CAAO,cAAA,CAAe,QAAQ,eAAA,EAAiB;AAAA,IAC7C,UAAA,EAAY,KAAA;AAAA,IACZ,OAAO,IAAA,CAAK;AAAA,GACb,CAAA;AACD,EAAA,MAAA,CAAO,cAAA,CAAe,QAAQ,WAAA,EAAa;AAAA,IACzC,UAAA,EAAY,KAAA;AAAA,IACZ,OAAO,IAAA,CAAK;AAAA,GACb,CAAA;AAED,EAAA,OAAO,MAAA;AACT;AAEA,SAAS,iBAAA,CACP,MAGA,IAAA,EAIA;AACA,EAAA,IAAI,SAAS,MAAA,EAAW;AACtB,IAAA,OAAO,CAAC,MAAqB,IAAI,CAAA;AAAA,EACnC;AACA,EAAA,OAAO;AAAA,IACL,IAAA;AAAA,IACA;AAAA,GACF;AACF","file":"createInfiniteQuery.cjs","sourcesContent":["import { attach, createEvent, createStore, sample, scopeBind } from 'effector'\nimport { InfiniteQueryObserver } from '@tanstack/query-core'\nimport type {\n  InfiniteData,\n  QueryClient,\n  QueryKey,\n} from '@tanstack/query-core'\nimport { createBaseQuery, sidConfig, warnMissingName } from './createBaseQuery'\nimport { resolveReactiveRefetchInterval } from './resolve'\nimport type {\n  CreateInfiniteQueryOptions,\n  InfiniteQueryResult,\n} from './types'\n\ntype Observer<TQueryFnData, TError, TData, TPageParam> = InfiniteQueryObserver<\n  TQueryFnData,\n  TError,\n  TData,\n  QueryKey,\n  TPageParam\n>\n\ntype ObserverResult<TQueryFnData, TError, TData, TPageParam> = ReturnType<\n  Observer<TQueryFnData, TError, TData, TPageParam>['getCurrentResult']\n>\n\nexport function createInfiniteQuery<\n  TQueryFnData = unknown,\n  TError = Error,\n  TPageParam = unknown,\n  TData = InfiniteData<TQueryFnData, TPageParam>,\n>(\n  options: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,\n): InfiniteQueryResult<TData, TError, TPageParam>\nexport function createInfiniteQuery<\n  TQueryFnData = unknown,\n  TError = Error,\n  TPageParam = unknown,\n  TData = InfiniteData<TQueryFnData, TPageParam>,\n>(\n  queryClient: QueryClient,\n  options: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,\n): InfiniteQueryResult<TData, TError, TPageParam>\nexport function createInfiniteQuery<\n  TQueryFnData = unknown,\n  TError = Error,\n  TPageParam = unknown,\n  TData = InfiniteData<TQueryFnData, TPageParam>,\n>(\n  arg1:\n    | QueryClient\n    | CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,\n  arg2?: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,\n): InfiniteQueryResult<TData, TError, TPageParam> {\n  const [explicitClient, options] = parseInfiniteArgs<\n    TQueryFnData,\n    TError,\n    TPageParam,\n    TData\n  >(arg1, arg2)\n  const { queryKey, enabled, name, ...restOptions } = options\n\n  if (!name) warnMissingName('createInfiniteQuery')\n\n  const reactiveRefetchInterval = resolveReactiveRefetchInterval(\n    (restOptions as { refetchInterval?: unknown }).refetchInterval,\n  )\n  if (reactiveRefetchInterval) {\n    delete (restOptions as { refetchInterval?: unknown }).refetchInterval\n  }\n\n  const base = createBaseQuery<\n    TData,\n    TError,\n    ObserverResult<TQueryFnData, TError, TData, TPageParam>,\n    Observer<TQueryFnData, TError, TData, TPageParam>,\n    {\n      $hasNextPage: ReturnType<typeof createStore<boolean>>\n      $hasPreviousPage: ReturnType<typeof createStore<boolean>>\n      $isFetchingNextPage: ReturnType<typeof createStore<boolean>>\n      $isFetchingPreviousPage: ReturnType<typeof createStore<boolean>>\n      $isFetchNextPageError: ReturnType<typeof createStore<boolean>>\n      $isFetchPreviousPageError: ReturnType<typeof createStore<boolean>>\n      fetchNextPage: ReturnType<typeof createEvent<void>>\n      fetchPreviousPage: ReturnType<typeof createEvent<void>>\n    }\n  >(\n    explicitClient,\n    { queryKey, enabled, name, reactiveRefetchInterval },\n    {\n      createObserver: (qc, { queryKey: key, enabled: isEnabled }) =>\n        new InfiniteQueryObserver<\n          TQueryFnData,\n          TError,\n          TData,\n          QueryKey,\n          TPageParam\n        >(qc, {\n          ...restOptions,\n          queryKey: key,\n          enabled: isEnabled,\n        } as any),\n      setupExtras: () => {\n        const hasNextPageUpdated = createEvent<boolean>()\n        const hasPreviousPageUpdated = createEvent<boolean>()\n        const isFetchingNextPageUpdated = createEvent<boolean>()\n        const isFetchingPreviousPageUpdated = createEvent<boolean>()\n        const isFetchNextPageErrorUpdated = createEvent<boolean>()\n        const isFetchPreviousPageErrorUpdated = createEvent<boolean>()\n\n        const $hasNextPage = createStore(false, {\n          ...sidConfig(name, '$hasNextPage'),\n        }).on(hasNextPageUpdated, (_, v) => v)\n        const $hasPreviousPage = createStore(false, {\n          ...sidConfig(name, '$hasPreviousPage'),\n        }).on(hasPreviousPageUpdated, (_, v) => v)\n        const $isFetchingNextPage = createStore(false, {\n          ...sidConfig(name, '$isFetchingNextPage'),\n        }).on(isFetchingNextPageUpdated, (_, v) => v)\n        const $isFetchingPreviousPage = createStore(false, {\n          ...sidConfig(name, '$isFetchingPreviousPage'),\n        }).on(isFetchingPreviousPageUpdated, (_, v) => v)\n        const $isFetchNextPageError = createStore(false, {\n          ...sidConfig(name, '$isFetchNextPageError'),\n        }).on(isFetchNextPageErrorUpdated, (_, v) => v)\n        const $isFetchPreviousPageError = createStore(false, {\n          ...sidConfig(name, '$isFetchPreviousPageError'),\n        }).on(isFetchPreviousPageErrorUpdated, (_, v) => v)\n\n        const fetchNextPage = createEvent<void>()\n        const fetchPreviousPage = createEvent<void>()\n\n        return {\n          stores: {\n            $hasNextPage,\n            $hasPreviousPage,\n            $isFetchingNextPage,\n            $isFetchingPreviousPage,\n            $isFetchNextPageError,\n            $isFetchPreviousPageError,\n            fetchNextPage,\n            fetchPreviousPage,\n          },\n          // Wire fetchNextPage / fetchPreviousPage as scope-aware effects via\n          // attach over $observer — same pattern as the rest of createBaseQuery.\n          setupEffects: ({ $observer }) => {\n            const fetchNextPageFx = attach({\n              source: $observer,\n              effect: (observer) => {\n                if (!observer) return\n                observer.fetchNextPage()\n              },\n            })\n            sample({ clock: fetchNextPage, target: fetchNextPageFx })\n\n            const fetchPreviousPageFx = attach({\n              source: $observer,\n              effect: (observer) => {\n                if (!observer) return\n                observer.fetchPreviousPage()\n              },\n            })\n            sample({ clock: fetchPreviousPage, target: fetchPreviousPageFx })\n          },\n          bindDispatcher: () => {\n            const dispatchHasNextPage = scopeBind(hasNextPageUpdated, {\n              safe: true,\n            })\n            const dispatchHasPreviousPage = scopeBind(hasPreviousPageUpdated, {\n              safe: true,\n            })\n            const dispatchIsFetchingNextPage = scopeBind(\n              isFetchingNextPageUpdated,\n              { safe: true },\n            )\n            const dispatchIsFetchingPreviousPage = scopeBind(\n              isFetchingPreviousPageUpdated,\n              { safe: true },\n            )\n            const dispatchIsFetchNextPageError = scopeBind(\n              isFetchNextPageErrorUpdated,\n              { safe: true },\n            )\n            const dispatchIsFetchPreviousPageError = scopeBind(\n              isFetchPreviousPageErrorUpdated,\n              { safe: true },\n            )\n\n            return (result) => {\n              dispatchHasNextPage(result.hasNextPage)\n              dispatchHasPreviousPage(result.hasPreviousPage)\n              dispatchIsFetchingNextPage(result.isFetchingNextPage)\n              dispatchIsFetchingPreviousPage(result.isFetchingPreviousPage)\n              dispatchIsFetchNextPageError(result.isFetchNextPageError)\n              dispatchIsFetchPreviousPageError(result.isFetchPreviousPageError)\n            }\n          },\n        }\n      },\n    },\n  )\n\n  // See createQuery.prefetch — same contract, but uses fetchInfiniteQuery so\n  // the first page is fetched + cached on the server.\n  const prefetch = createEvent<void>()\n  const prefetchFx = attach({\n    source: {\n      qc: base.$queryClient,\n      key: base.$resolvedKey,\n      enabled: base.$enabled,\n    },\n    effect: ({ qc, key, enabled }) => {\n      if (!qc || !enabled) return\n      return qc.fetchInfiniteQuery({\n        ...restOptions,\n        queryKey: key,\n      } as any)\n    },\n  })\n  sample({ clock: prefetch, target: prefetchFx })\n\n  const result: InfiniteQueryResult<TData, TError, TPageParam> = {\n    $data: base.$data,\n    $error: base.$error,\n    $status: base.$status,\n    $isPending: base.$isPending,\n    $isFetching: base.$isFetching,\n    $isSuccess: base.$isSuccess,\n    $isError: base.$isError,\n    $isPlaceholderData: base.$isPlaceholderData,\n    $fetchStatus: base.$fetchStatus,\n    $hasNextPage: base.$hasNextPage,\n    $hasPreviousPage: base.$hasPreviousPage,\n    $isFetchingNextPage: base.$isFetchingNextPage,\n    $isFetchingPreviousPage: base.$isFetchingPreviousPage,\n    $isFetchNextPageError: base.$isFetchNextPageError,\n    $isFetchPreviousPageError: base.$isFetchPreviousPageError,\n    $observer: base.$observer,\n    $queryClient: base.$queryClient,\n    fetchNextPage: base.fetchNextPage,\n    fetchPreviousPage: base.fetchPreviousPage,\n    refresh: base.refresh,\n    prefetch,\n    mounted: base.mounted,\n    unmounted: base.unmounted,\n  }\n\n  Object.defineProperty(result, '__createObserver', {\n    enumerable: false,\n    value: (qc: QueryClient, init: { queryKey: any; enabled: boolean }) =>\n      new InfiniteQueryObserver<\n        TQueryFnData,\n        TError,\n        TData,\n        QueryKey,\n        TPageParam\n      >(qc, {\n        ...restOptions,\n        queryKey: init.queryKey,\n        enabled: init.enabled,\n      } as any),\n  })\n  Object.defineProperty(result, '__resolvedKey', {\n    enumerable: false,\n    value: base.$resolvedKey,\n  })\n  Object.defineProperty(result, '__enabled', {\n    enumerable: false,\n    value: base.$enabled,\n  })\n\n  return result\n}\n\nfunction parseInfiniteArgs<TQueryFnData, TError, TPageParam, TData>(\n  arg1:\n    | QueryClient\n    | CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,\n  arg2?: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,\n): [\n  QueryClient | null,\n  CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,\n] {\n  if (arg2 !== undefined) {\n    return [arg1 as QueryClient, arg2]\n  }\n  return [\n    null,\n    arg1 as CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,\n  ]\n}\n"]}

package/dist/createInfiniteQuery.d.cts

@@ -0,0 +1,8 @@
+import { InfiniteData, QueryClient } from '@tanstack/query-core';
+import { CreateInfiniteQueryOptions, InfiniteQueryResult } from './types.cjs';
+import 'effector';
+
+declare function createInfiniteQuery<TQueryFnData = unknown, TError = Error, TPageParam = unknown, TData = InfiniteData<TQueryFnData, TPageParam>>(options: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>): InfiniteQueryResult<TData, TError, TPageParam>;
+declare function createInfiniteQuery<TQueryFnData = unknown, TError = Error, TPageParam = unknown, TData = InfiniteData<TQueryFnData, TPageParam>>(queryClient: QueryClient, options: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>): InfiniteQueryResult<TData, TError, TPageParam>;
+
+export { createInfiniteQuery };

package/dist/createInfiniteQuery.d.ts

@@ -0,0 +1,8 @@
+import { InfiniteData, QueryClient } from '@tanstack/query-core';
+import { CreateInfiniteQueryOptions, InfiniteQueryResult } from './types.js';
+import 'effector';
+
+declare function createInfiniteQuery<TQueryFnData = unknown, TError = Error, TPageParam = unknown, TData = InfiniteData<TQueryFnData, TPageParam>>(options: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>): InfiniteQueryResult<TData, TError, TPageParam>;
+declare function createInfiniteQuery<TQueryFnData = unknown, TError = Error, TPageParam = unknown, TData = InfiniteData<TQueryFnData, TPageParam>>(queryClient: QueryClient, options: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>): InfiniteQueryResult<TData, TError, TPageParam>;
+
+export { createInfiniteQuery };