@effector-tanstack-query/core 0.1.0

package/dist/createInfiniteQuery.js

@@ -0,0 +1,191 @@
+import { createEvent, createStore, scopeBind, attach, sample } from 'effector';
+import { InfiniteQueryObserver } from '@tanstack/query-core';
+import { warnMissingName, createBaseQuery, sidConfig } from './createBaseQuery.js';
+import { resolveReactiveRefetchInterval } from './resolve.js';
+
+// src/createInfiniteQuery.ts
+function createInfiniteQuery(arg1, arg2) {
+  const [explicitClient, options] = parseInfiniteArgs(arg1, arg2);
+  const { queryKey, enabled, name, ...restOptions } = options;
+  if (!name) warnMissingName("createInfiniteQuery");
+  const reactiveRefetchInterval = resolveReactiveRefetchInterval(
+    restOptions.refetchInterval
+  );
+  if (reactiveRefetchInterval) {
+    delete restOptions.refetchInterval;
+  }
+  const base = createBaseQuery(
+    explicitClient,
+    { queryKey, enabled, name, reactiveRefetchInterval },
+    {
+      createObserver: (qc, { queryKey: key, enabled: isEnabled }) => new InfiniteQueryObserver(qc, {
+        ...restOptions,
+        queryKey: key,
+        enabled: isEnabled
+      }),
+      setupExtras: () => {
+        const hasNextPageUpdated = createEvent();
+        const hasPreviousPageUpdated = createEvent();
+        const isFetchingNextPageUpdated = createEvent();
+        const isFetchingPreviousPageUpdated = createEvent();
+        const isFetchNextPageErrorUpdated = createEvent();
+        const isFetchPreviousPageErrorUpdated = createEvent();
+        const $hasNextPage = createStore(false, {
+          ...sidConfig(name, "$hasNextPage")
+        }).on(hasNextPageUpdated, (_, v) => v);
+        const $hasPreviousPage = createStore(false, {
+          ...sidConfig(name, "$hasPreviousPage")
+        }).on(hasPreviousPageUpdated, (_, v) => v);
+        const $isFetchingNextPage = createStore(false, {
+          ...sidConfig(name, "$isFetchingNextPage")
+        }).on(isFetchingNextPageUpdated, (_, v) => v);
+        const $isFetchingPreviousPage = createStore(false, {
+          ...sidConfig(name, "$isFetchingPreviousPage")
+        }).on(isFetchingPreviousPageUpdated, (_, v) => v);
+        const $isFetchNextPageError = createStore(false, {
+          ...sidConfig(name, "$isFetchNextPageError")
+        }).on(isFetchNextPageErrorUpdated, (_, v) => v);
+        const $isFetchPreviousPageError = createStore(false, {
+          ...sidConfig(name, "$isFetchPreviousPageError")
+        }).on(isFetchPreviousPageErrorUpdated, (_, v) => v);
+        const fetchNextPage = createEvent();
+        const fetchPreviousPage = 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 = attach({
+              source: $observer,
+              effect: (observer) => {
+                if (!observer) return;
+                observer.fetchNextPage();
+              }
+            });
+            sample({ clock: fetchNextPage, target: fetchNextPageFx });
+            const fetchPreviousPageFx = attach({
+              source: $observer,
+              effect: (observer) => {
+                if (!observer) return;
+                observer.fetchPreviousPage();
+              }
+            });
+            sample({ clock: fetchPreviousPage, target: fetchPreviousPageFx });
+          },
+          bindDispatcher: () => {
+            const dispatchHasNextPage = scopeBind(hasNextPageUpdated, {
+              safe: true
+            });
+            const dispatchHasPreviousPage = scopeBind(hasPreviousPageUpdated, {
+              safe: true
+            });
+            const dispatchIsFetchingNextPage = scopeBind(
+              isFetchingNextPageUpdated,
+              { safe: true }
+            );
+            const dispatchIsFetchingPreviousPage = scopeBind(
+              isFetchingPreviousPageUpdated,
+              { safe: true }
+            );
+            const dispatchIsFetchNextPageError = scopeBind(
+              isFetchNextPageErrorUpdated,
+              { safe: true }
+            );
+            const dispatchIsFetchPreviousPageError = 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 = createEvent();
+  const prefetchFx = 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
+      });
+    }
+  });
+  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 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
+  ];
+}
+
+export { createInfiniteQuery };
+//# sourceMappingURL=createInfiniteQuery.js.map
+//# sourceMappingURL=createInfiniteQuery.js.map

package/dist/createInfiniteQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createInfiniteQuery.ts"],"names":["result","enabled"],"mappings":"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","file":"createInfiniteQuery.js","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/createInvalidate.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var effector = require('effector');
+var queryClient_cjs = require('./queryClient.cjs');
+var resolve_cjs = require('./resolve.cjs');
+
+// src/createInvalidate.ts
+function createInvalidate(arg1, arg2) {
+  const [explicitClient, options] = parseArgs(arg1, arg2);
+  const { queryKey, exact, refetchType, type } = options;
+  const $effectiveClient = explicitClient ? effector.createStore(explicitClient, {
+    serialize: "ignore"
+  }) : queryClient_cjs.$queryClient;
+  const $resolvedKey = resolve_cjs.resolveKey(queryKey);
+  const invalidate = effector.createEvent();
+  const invalidateFx = effector.attach({
+    source: { qc: $effectiveClient, key: $resolvedKey },
+    effect: ({ qc, key }) => {
+      if (!qc) return;
+      const filters = { queryKey: key };
+      if (exact !== void 0) filters.exact = exact;
+      if (refetchType !== void 0) filters.refetchType = refetchType;
+      if (type !== void 0) filters.type = type;
+      return qc.invalidateQueries(filters);
+    }
+  });
+  effector.sample({ clock: invalidate, target: invalidateFx });
+  return invalidate;
+}
+function parseArgs(arg1, arg2) {
+  if (arg2 !== void 0) return [arg1, arg2];
+  return [null, arg1];
+}
+
+exports.createInvalidate = createInvalidate;
+//# sourceMappingURL=createInvalidate.cjs.map
+//# sourceMappingURL=createInvalidate.cjs.map

package/dist/createInvalidate.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createInvalidate.ts"],"names":["createStore","$queryClient","resolveKey","createEvent","attach","sample"],"mappings":";;;;;;;AA4DO,SAAS,gBAAA,CACd,MACA,IAAA,EACqB;AACrB,EAAA,MAAM,CAAC,cAAA,EAAgB,OAAO,CAAA,GAAI,SAAA,CAAU,MAAM,IAAI,CAAA;AACtD,EAAA,MAAM,EAAE,QAAA,EAAU,KAAA,EAAO,WAAA,EAAa,MAAK,GAAI,OAAA;AAK/C,EAAA,MAAM,gBAAA,GAA8C,cAAA,GAChDA,oBAAA,CAAY,cAAA,EAAsC;AAAA,IAChD,SAAA,EAAW;AAAA,GACZ,CAAA,GACDC,4BAAA;AAEJ,EAAA,MAAM,YAAA,GAAeC,uBAAW,QAAQ,CAAA;AAExC,EAAA,MAAM,aAAaC,oBAAA,EAAkB;AAErC,EAAA,MAAM,eAAeC,eAAA,CAAO;AAAA,IAC1B,MAAA,EAAQ,EAAE,EAAA,EAAI,gBAAA,EAAkB,KAAK,YAAA,EAAa;AAAA,IAClD,MAAA,EAAQ,CAAC,EAAE,EAAA,EAAI,KAAI,KAAM;AACvB,MAAA,IAAI,CAAC,EAAA,EAAI;AACT,MAAA,MAAM,OAAA,GAAkC,EAAE,QAAA,EAAU,GAAA,EAAI;AACxD,MAAA,IAAI,KAAA,KAAU,MAAA,EAAW,OAAA,CAAQ,KAAA,GAAQ,KAAA;AACzC,MAAA,IAAI,WAAA,KAAgB,MAAA,EAAW,OAAA,CAAQ,WAAA,GAAc,WAAA;AACrD,MAAA,IAAI,IAAA,KAAS,MAAA,EAAW,OAAA,CAAQ,IAAA,GAAO,IAAA;AACvC,MAAA,OAAO,EAAA,CAAG,kBAAkB,OAAO,CAAA;AAAA,IACrC;AAAA,GACD,CAAA;AAED,EAAAC,eAAA,CAAO,EAAE,KAAA,EAAO,UAAA,EAAY,MAAA,EAAQ,cAAc,CAAA;AAElD,EAAA,OAAO,UAAA;AACT;AAEA,SAAS,SAAA,CACP,MACA,IAAA,EAC+C;AAC/C,EAAA,IAAI,IAAA,KAAS,MAAA,EAAW,OAAO,CAAC,MAAqB,IAAI,CAAA;AACzD,EAAA,OAAO,CAAC,MAAM,IAA+B,CAAA;AAC/C","file":"createInvalidate.cjs","sourcesContent":["import { attach, createEvent, createStore, sample } from 'effector'\nimport type { EventCallable, Store } from 'effector'\nimport type {\n  InvalidateQueryFilters,\n  QueryClient,\n} from '@tanstack/query-core'\nimport { $queryClient } from './queryClient'\nimport { resolveKey } from './resolve'\nimport type { EffectorQueryKey } from './types'\n\nexport interface CreateInvalidateOptions {\n  /**\n   * Key (or key prefix) to invalidate. Supports the same reactive shape as\n   * `createQuery.queryKey` — drop a `Store` anywhere in the array and the\n   * invalidate event will resolve it on every call, so dynamic keys \"just\n   * work\".\n   */\n  queryKey: EffectorQueryKey\n  /**\n   * Forwarded to `queryClient.invalidateQueries({ exact })`. With `exact: true`\n   * only queries whose key *exactly* matches are invalidated; otherwise the\n   * key is treated as a prefix.\n   */\n  exact?: boolean\n  /**\n   * Forwarded to `queryClient.invalidateQueries({ refetchType })`. Controls\n   * which observers refetch immediately after invalidation. Defaults to\n   * `'active'` (TanStack Query's own default).\n   */\n  refetchType?: 'active' | 'inactive' | 'all' | 'none'\n  /**\n   * Forwarded to `queryClient.invalidateQueries({ type })`. Filters which\n   * queries match — `'active'`, `'inactive'`, `'all'`.\n   */\n  type?: 'active' | 'inactive' | 'all'\n}\n\n/**\n * Builds an effector event that invalidates a query (or a key prefix) on the\n * resolved `QueryClient`. Useful when you want to invalidate a query\n * declaratively from a `sample` (e.g. on a mutation's `finished.success`)\n * without writing a one-off `attach` every time.\n *\n * @example Static key\n * const invalidateFavorites = createInvalidate({ queryKey: ['favorites'] })\n * sample({ clock: addFavorite.finished.success, target: invalidateFavorites })\n *\n * @example Reactive key — uses current $userId at invocation time\n * const invalidateUser = createInvalidate({ queryKey: ['user', $userId] })\n *\n * @example Explicit client (same back-compat overload as the other factories)\n * const invalidateFavorites = createInvalidate(queryClient, { queryKey: ['favorites'] })\n */\nexport function createInvalidate(\n  options: CreateInvalidateOptions,\n): EventCallable<void>\nexport function createInvalidate(\n  queryClient: QueryClient,\n  options: CreateInvalidateOptions,\n): EventCallable<void>\nexport function createInvalidate(\n  arg1: QueryClient | CreateInvalidateOptions,\n  arg2?: CreateInvalidateOptions,\n): EventCallable<void> {\n  const [explicitClient, options] = parseArgs(arg1, arg2)\n  const { queryKey, exact, refetchType, type } = options\n\n  // Same locking semantics as the other factories: explicit client freezes\n  // the store, default flows through global $queryClient (and respects\n  // fork({ values: [[$queryClient, qc]] }) for 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 $resolvedKey = resolveKey(queryKey)\n\n  const invalidate = createEvent<void>()\n\n  const invalidateFx = attach({\n    source: { qc: $effectiveClient, key: $resolvedKey },\n    effect: ({ qc, key }) => {\n      if (!qc) return\n      const filters: InvalidateQueryFilters = { queryKey: key }\n      if (exact !== undefined) filters.exact = exact\n      if (refetchType !== undefined) filters.refetchType = refetchType\n      if (type !== undefined) filters.type = type\n      return qc.invalidateQueries(filters)\n    },\n  })\n\n  sample({ clock: invalidate, target: invalidateFx })\n\n  return invalidate\n}\n\nfunction parseArgs(\n  arg1: QueryClient | CreateInvalidateOptions,\n  arg2?: CreateInvalidateOptions,\n): [QueryClient | null, CreateInvalidateOptions] {\n  if (arg2 !== undefined) return [arg1 as QueryClient, arg2]\n  return [null, arg1 as CreateInvalidateOptions]\n}\n"]}

package/dist/createInvalidate.d.cts

@@ -0,0 +1,50 @@
+import { EventCallable } from 'effector';
+import { QueryClient } from '@tanstack/query-core';
+import { EffectorQueryKey } from './types.cjs';
+
+interface CreateInvalidateOptions {
+    /**
+     * Key (or key prefix) to invalidate. Supports the same reactive shape as
+     * `createQuery.queryKey` — drop a `Store` anywhere in the array and the
+     * invalidate event will resolve it on every call, so dynamic keys "just
+     * work".
+     */
+    queryKey: EffectorQueryKey;
+    /**
+     * Forwarded to `queryClient.invalidateQueries({ exact })`. With `exact: true`
+     * only queries whose key *exactly* matches are invalidated; otherwise the
+     * key is treated as a prefix.
+     */
+    exact?: boolean;
+    /**
+     * Forwarded to `queryClient.invalidateQueries({ refetchType })`. Controls
+     * which observers refetch immediately after invalidation. Defaults to
+     * `'active'` (TanStack Query's own default).
+     */
+    refetchType?: 'active' | 'inactive' | 'all' | 'none';
+    /**
+     * Forwarded to `queryClient.invalidateQueries({ type })`. Filters which
+     * queries match — `'active'`, `'inactive'`, `'all'`.
+     */
+    type?: 'active' | 'inactive' | 'all';
+}
+/**
+ * Builds an effector event that invalidates a query (or a key prefix) on the
+ * resolved `QueryClient`. Useful when you want to invalidate a query
+ * declaratively from a `sample` (e.g. on a mutation's `finished.success`)
+ * without writing a one-off `attach` every time.
+ *
+ * @example Static key
+ * const invalidateFavorites = createInvalidate({ queryKey: ['favorites'] })
+ * sample({ clock: addFavorite.finished.success, target: invalidateFavorites })
+ *
+ * @example Reactive key — uses current $userId at invocation time
+ * const invalidateUser = createInvalidate({ queryKey: ['user', $userId] })
+ *
+ * @example Explicit client (same back-compat overload as the other factories)
+ * const invalidateFavorites = createInvalidate(queryClient, { queryKey: ['favorites'] })
+ */
+declare function createInvalidate(options: CreateInvalidateOptions): EventCallable<void>;
+declare function createInvalidate(queryClient: QueryClient, options: CreateInvalidateOptions): EventCallable<void>;
+
+export { type CreateInvalidateOptions, createInvalidate };

package/dist/createInvalidate.d.ts

@@ -0,0 +1,50 @@
+import { EventCallable } from 'effector';
+import { QueryClient } from '@tanstack/query-core';
+import { EffectorQueryKey } from './types.js';
+
+interface CreateInvalidateOptions {
+    /**
+     * Key (or key prefix) to invalidate. Supports the same reactive shape as
+     * `createQuery.queryKey` — drop a `Store` anywhere in the array and the
+     * invalidate event will resolve it on every call, so dynamic keys "just
+     * work".
+     */
+    queryKey: EffectorQueryKey;
+    /**
+     * Forwarded to `queryClient.invalidateQueries({ exact })`. With `exact: true`
+     * only queries whose key *exactly* matches are invalidated; otherwise the
+     * key is treated as a prefix.
+     */
+    exact?: boolean;
+    /**
+     * Forwarded to `queryClient.invalidateQueries({ refetchType })`. Controls
+     * which observers refetch immediately after invalidation. Defaults to
+     * `'active'` (TanStack Query's own default).
+     */
+    refetchType?: 'active' | 'inactive' | 'all' | 'none';
+    /**
+     * Forwarded to `queryClient.invalidateQueries({ type })`. Filters which
+     * queries match — `'active'`, `'inactive'`, `'all'`.
+     */
+    type?: 'active' | 'inactive' | 'all';
+}
+/**
+ * Builds an effector event that invalidates a query (or a key prefix) on the
+ * resolved `QueryClient`. Useful when you want to invalidate a query
+ * declaratively from a `sample` (e.g. on a mutation's `finished.success`)
+ * without writing a one-off `attach` every time.
+ *
+ * @example Static key
+ * const invalidateFavorites = createInvalidate({ queryKey: ['favorites'] })
+ * sample({ clock: addFavorite.finished.success, target: invalidateFavorites })
+ *
+ * @example Reactive key — uses current $userId at invocation time
+ * const invalidateUser = createInvalidate({ queryKey: ['user', $userId] })
+ *
+ * @example Explicit client (same back-compat overload as the other factories)
+ * const invalidateFavorites = createInvalidate(queryClient, { queryKey: ['favorites'] })
+ */
+declare function createInvalidate(options: CreateInvalidateOptions): EventCallable<void>;
+declare function createInvalidate(queryClient: QueryClient, options: CreateInvalidateOptions): EventCallable<void>;
+
+export { type CreateInvalidateOptions, createInvalidate };

package/dist/createInvalidate.js

@@ -0,0 +1,35 @@
+import { createStore, createEvent, attach, sample } from 'effector';
+import { $queryClient } from './queryClient.js';
+import { resolveKey } from './resolve.js';
+
+// src/createInvalidate.ts
+function createInvalidate(arg1, arg2) {
+  const [explicitClient, options] = parseArgs(arg1, arg2);
+  const { queryKey, exact, refetchType, type } = options;
+  const $effectiveClient = explicitClient ? createStore(explicitClient, {
+    serialize: "ignore"
+  }) : $queryClient;
+  const $resolvedKey = resolveKey(queryKey);
+  const invalidate = createEvent();
+  const invalidateFx = attach({
+    source: { qc: $effectiveClient, key: $resolvedKey },
+    effect: ({ qc, key }) => {
+      if (!qc) return;
+      const filters = { queryKey: key };
+      if (exact !== void 0) filters.exact = exact;
+      if (refetchType !== void 0) filters.refetchType = refetchType;
+      if (type !== void 0) filters.type = type;
+      return qc.invalidateQueries(filters);
+    }
+  });
+  sample({ clock: invalidate, target: invalidateFx });
+  return invalidate;
+}
+function parseArgs(arg1, arg2) {
+  if (arg2 !== void 0) return [arg1, arg2];
+  return [null, arg1];
+}
+
+export { createInvalidate };
+//# sourceMappingURL=createInvalidate.js.map
+//# sourceMappingURL=createInvalidate.js.map

package/dist/createInvalidate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createInvalidate.ts"],"names":[],"mappings":";;;;;AA4DO,SAAS,gBAAA,CACd,MACA,IAAA,EACqB;AACrB,EAAA,MAAM,CAAC,cAAA,EAAgB,OAAO,CAAA,GAAI,SAAA,CAAU,MAAM,IAAI,CAAA;AACtD,EAAA,MAAM,EAAE,QAAA,EAAU,KAAA,EAAO,WAAA,EAAa,MAAK,GAAI,OAAA;AAK/C,EAAA,MAAM,gBAAA,GAA8C,cAAA,GAChD,WAAA,CAAY,cAAA,EAAsC;AAAA,IAChD,SAAA,EAAW;AAAA,GACZ,CAAA,GACD,YAAA;AAEJ,EAAA,MAAM,YAAA,GAAe,WAAW,QAAQ,CAAA;AAExC,EAAA,MAAM,aAAa,WAAA,EAAkB;AAErC,EAAA,MAAM,eAAe,MAAA,CAAO;AAAA,IAC1B,MAAA,EAAQ,EAAE,EAAA,EAAI,gBAAA,EAAkB,KAAK,YAAA,EAAa;AAAA,IAClD,MAAA,EAAQ,CAAC,EAAE,EAAA,EAAI,KAAI,KAAM;AACvB,MAAA,IAAI,CAAC,EAAA,EAAI;AACT,MAAA,MAAM,OAAA,GAAkC,EAAE,QAAA,EAAU,GAAA,EAAI;AACxD,MAAA,IAAI,KAAA,KAAU,MAAA,EAAW,OAAA,CAAQ,KAAA,GAAQ,KAAA;AACzC,MAAA,IAAI,WAAA,KAAgB,MAAA,EAAW,OAAA,CAAQ,WAAA,GAAc,WAAA;AACrD,MAAA,IAAI,IAAA,KAAS,MAAA,EAAW,OAAA,CAAQ,IAAA,GAAO,IAAA;AACvC,MAAA,OAAO,EAAA,CAAG,kBAAkB,OAAO,CAAA;AAAA,IACrC;AAAA,GACD,CAAA;AAED,EAAA,MAAA,CAAO,EAAE,KAAA,EAAO,UAAA,EAAY,MAAA,EAAQ,cAAc,CAAA;AAElD,EAAA,OAAO,UAAA;AACT;AAEA,SAAS,SAAA,CACP,MACA,IAAA,EAC+C;AAC/C,EAAA,IAAI,IAAA,KAAS,MAAA,EAAW,OAAO,CAAC,MAAqB,IAAI,CAAA;AACzD,EAAA,OAAO,CAAC,MAAM,IAA+B,CAAA;AAC/C","file":"createInvalidate.js","sourcesContent":["import { attach, createEvent, createStore, sample } from 'effector'\nimport type { EventCallable, Store } from 'effector'\nimport type {\n  InvalidateQueryFilters,\n  QueryClient,\n} from '@tanstack/query-core'\nimport { $queryClient } from './queryClient'\nimport { resolveKey } from './resolve'\nimport type { EffectorQueryKey } from './types'\n\nexport interface CreateInvalidateOptions {\n  /**\n   * Key (or key prefix) to invalidate. Supports the same reactive shape as\n   * `createQuery.queryKey` — drop a `Store` anywhere in the array and the\n   * invalidate event will resolve it on every call, so dynamic keys \"just\n   * work\".\n   */\n  queryKey: EffectorQueryKey\n  /**\n   * Forwarded to `queryClient.invalidateQueries({ exact })`. With `exact: true`\n   * only queries whose key *exactly* matches are invalidated; otherwise the\n   * key is treated as a prefix.\n   */\n  exact?: boolean\n  /**\n   * Forwarded to `queryClient.invalidateQueries({ refetchType })`. Controls\n   * which observers refetch immediately after invalidation. Defaults to\n   * `'active'` (TanStack Query's own default).\n   */\n  refetchType?: 'active' | 'inactive' | 'all' | 'none'\n  /**\n   * Forwarded to `queryClient.invalidateQueries({ type })`. Filters which\n   * queries match — `'active'`, `'inactive'`, `'all'`.\n   */\n  type?: 'active' | 'inactive' | 'all'\n}\n\n/**\n * Builds an effector event that invalidates a query (or a key prefix) on the\n * resolved `QueryClient`. Useful when you want to invalidate a query\n * declaratively from a `sample` (e.g. on a mutation's `finished.success`)\n * without writing a one-off `attach` every time.\n *\n * @example Static key\n * const invalidateFavorites = createInvalidate({ queryKey: ['favorites'] })\n * sample({ clock: addFavorite.finished.success, target: invalidateFavorites })\n *\n * @example Reactive key — uses current $userId at invocation time\n * const invalidateUser = createInvalidate({ queryKey: ['user', $userId] })\n *\n * @example Explicit client (same back-compat overload as the other factories)\n * const invalidateFavorites = createInvalidate(queryClient, { queryKey: ['favorites'] })\n */\nexport function createInvalidate(\n  options: CreateInvalidateOptions,\n): EventCallable<void>\nexport function createInvalidate(\n  queryClient: QueryClient,\n  options: CreateInvalidateOptions,\n): EventCallable<void>\nexport function createInvalidate(\n  arg1: QueryClient | CreateInvalidateOptions,\n  arg2?: CreateInvalidateOptions,\n): EventCallable<void> {\n  const [explicitClient, options] = parseArgs(arg1, arg2)\n  const { queryKey, exact, refetchType, type } = options\n\n  // Same locking semantics as the other factories: explicit client freezes\n  // the store, default flows through global $queryClient (and respects\n  // fork({ values: [[$queryClient, qc]] }) for 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 $resolvedKey = resolveKey(queryKey)\n\n  const invalidate = createEvent<void>()\n\n  const invalidateFx = attach({\n    source: { qc: $effectiveClient, key: $resolvedKey },\n    effect: ({ qc, key }) => {\n      if (!qc) return\n      const filters: InvalidateQueryFilters = { queryKey: key }\n      if (exact !== undefined) filters.exact = exact\n      if (refetchType !== undefined) filters.refetchType = refetchType\n      if (type !== undefined) filters.type = type\n      return qc.invalidateQueries(filters)\n    },\n  })\n\n  sample({ clock: invalidate, target: invalidateFx })\n\n  return invalidate\n}\n\nfunction parseArgs(\n  arg1: QueryClient | CreateInvalidateOptions,\n  arg2?: CreateInvalidateOptions,\n): [QueryClient | null, CreateInvalidateOptions] {\n  if (arg2 !== undefined) return [arg1 as QueryClient, arg2]\n  return [null, arg1 as CreateInvalidateOptions]\n}\n"]}

package/dist/createMutation.cjs

@@ -0,0 +1,177 @@
+'use strict';
+
+var effector = require('effector');
+var queryCore = require('@tanstack/query-core');
+var queryClient_cjs = require('./queryClient.cjs');
+var createBaseQuery_cjs = require('./createBaseQuery.cjs');
+
+// src/createMutation.ts
+function createMutation(arg1, arg2) {
+  const [explicitClient, options] = parseMutationArgs(arg1, arg2);
+  const { name, ...observerOptions } = options;
+  if (!name) createBaseQuery_cjs.warnMissingName("createMutation");
+  const $effectiveClient = explicitClient ? effector.createStore(explicitClient, {
+    serialize: "ignore"
+  }) : queryClient_cjs.$queryClient;
+  const dataUpdated = effector.createEvent();
+  const errorUpdated = effector.createEvent();
+  const statusUpdated = effector.createEvent();
+  const variablesUpdated = effector.createEvent();
+  const isPausedUpdated = effector.createEvent();
+  const finishedSuccess = effector.createEvent();
+  const finishedFailure = effector.createEvent();
+  const $data = effector.createStore(void 0, {
+    skipVoid: false,
+    ...createBaseQuery_cjs.sidConfig(name, "$data")
+  }).on(dataUpdated, (_, v) => v);
+  const $error = effector.createStore(null, {
+    skipVoid: false,
+    ...createBaseQuery_cjs.sidConfig(name, "$error")
+  }).on(errorUpdated, (_, v) => v);
+  const $status = effector.createStore("idle", {
+    ...createBaseQuery_cjs.sidConfig(name, "$status")
+  }).on(statusUpdated, (_, v) => v);
+  const $variables = effector.createStore(void 0, {
+    skipVoid: false,
+    ...createBaseQuery_cjs.sidConfig(name, "$variables")
+  }).on(variablesUpdated, (_, v) => v);
+  const $isPaused = effector.createStore(false, {
+    ...createBaseQuery_cjs.sidConfig(name, "$isPaused")
+  }).on(isPausedUpdated, (_, v) => v);
+  const $isPending = $status.map((s) => s === "pending");
+  const $isSuccess = $status.map((s) => s === "success");
+  const $isError = $status.map((s) => s === "error");
+  const $isIdle = $status.map((s) => s === "idle");
+  const $observer = effector.createStore(null, {
+    serialize: "ignore"
+  });
+  const observerCreated = effector.createEvent();
+  $observer.on(observerCreated, (_, obs) => obs);
+  const observerSubscriptions = /* @__PURE__ */ new WeakMap();
+  const start = effector.createEvent();
+  const unmounted = effector.createEvent();
+  const startFx = effector.attach({
+    source: { qc: $effectiveClient, observer: $observer },
+    effect: ({ qc, observer: existingObserver }) => {
+      if (!qc) {
+        throw new Error(
+          "[@tanstack/query-effector] No QueryClient is set for createMutation. Call setQueryClient(qc) before start, pass it to fork({ values: [[$queryClient, qc]] }), or pass it explicitly to the factory."
+        );
+      }
+      const observer = existingObserver ?? new queryCore.MutationObserver(
+        qc,
+        observerOptions
+      );
+      const dispatchData = effector.scopeBind(dataUpdated, { safe: true });
+      const dispatchError = effector.scopeBind(errorUpdated, { safe: true });
+      const dispatchStatus = effector.scopeBind(statusUpdated, { safe: true });
+      const dispatchVariables = effector.scopeBind(variablesUpdated, { safe: true });
+      const dispatchIsPaused = effector.scopeBind(isPausedUpdated, { safe: true });
+      const dispatchFinishedSuccess = effector.scopeBind(finishedSuccess, { safe: true });
+      const dispatchFinishedFailure = effector.scopeBind(finishedFailure, { safe: true });
+      observerSubscriptions.get(observer)?.();
+      let prevStatus = "idle";
+      const unsubscribe = observer.subscribe((result) => {
+        dispatchData(result.data);
+        dispatchError(result.error);
+        dispatchStatus(result.status);
+        dispatchVariables(result.variables);
+        dispatchIsPaused(result.isPaused);
+        if (prevStatus === "pending") {
+          if (result.status === "success") {
+            dispatchFinishedSuccess({
+              params: result.variables,
+              result: result.data
+            });
+          } else if (result.status === "error") {
+            dispatchFinishedFailure({
+              params: result.variables,
+              error: result.error
+            });
+          }
+        }
+        prevStatus = result.status;
+      });
+      observerSubscriptions.set(observer, unsubscribe);
+      return observer;
+    }
+  });
+  effector.sample({ clock: start, target: startFx });
+  effector.sample({ clock: startFx.doneData, target: observerCreated });
+  const unmountFx = effector.attach({
+    source: $observer,
+    effect: (observer) => {
+      if (!observer) return;
+      observerSubscriptions.get(observer)?.();
+      observerSubscriptions.delete(observer);
+    }
+  });
+  effector.sample({ clock: unmounted, target: unmountFx });
+  const mutate = effector.createEvent();
+  const mutateFx = effector.attach({
+    source: $observer,
+    effect: (observer, variables) => {
+      if (!observer) return;
+      observer.mutate(variables).catch(() => {
+      });
+    }
+  });
+  effector.sample({ clock: mutate, target: mutateFx });
+  const mutateWith = effector.createEvent();
+  const mutateWithFx = effector.attach({
+    source: $observer,
+    effect: (observer, {
+      variables,
+      ...callbacks
+    }) => {
+      if (!observer) return;
+      observer.mutate(variables, callbacks).catch(() => {
+      });
+    }
+  });
+  effector.sample({ clock: mutateWith, target: mutateWithFx });
+  const reset = effector.createEvent();
+  const resetFx = effector.attach({
+    source: $observer,
+    effect: (observer) => {
+      if (!observer) return;
+      observer.reset();
+    }
+  });
+  effector.sample({ clock: reset, target: resetFx });
+  return {
+    $data,
+    $error,
+    $status,
+    $variables,
+    $isPaused,
+    $isPending,
+    $isSuccess,
+    $isError,
+    $isIdle,
+    $observer,
+    $queryClient: $effectiveClient,
+    mutate,
+    mutateWith,
+    reset,
+    start,
+    unmounted,
+    finished: {
+      success: finishedSuccess,
+      failure: finishedFailure
+    }
+  };
+}
+function parseMutationArgs(arg1, arg2) {
+  if (arg2 !== void 0) {
+    return [arg1, arg2];
+  }
+  return [
+    null,
+    arg1
+  ];
+}
+
+exports.createMutation = createMutation;
+//# sourceMappingURL=createMutation.cjs.map
+//# sourceMappingURL=createMutation.cjs.map

package/dist/createMutation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createMutation.ts"],"names":["warnMissingName","createStore","$queryClient","createEvent","sidConfig","attach","MutationObserver","scopeBind","sample"],"mappings":"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","file":"createMutation.cjs","sourcesContent":["import {\n  attach,\n  createEvent,\n  createStore,\n  sample,\n  scopeBind,\n} from 'effector'\nimport type { Store } from 'effector'\nimport { MutationObserver } from '@tanstack/query-core'\nimport type { MutateOptions, QueryClient } from '@tanstack/query-core'\nimport { $queryClient } from './queryClient'\nimport { sidConfig, warnMissingName } from './createBaseQuery'\nimport type { CreateMutationOptions, MutationResult } from './types'\n\ntype MutationStatus = 'idle' | 'pending' | 'success' | 'error'\n\nexport function createMutation<\n  TData = unknown,\n  TError = Error,\n  TVariables = void,\n  TOnMutateResult = unknown,\n>(\n  arg1:\n    | QueryClient\n    | CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n  arg2?: CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n): MutationResult<TData, TError, TVariables> {\n  const [explicitClient, options] = parseMutationArgs<\n    TData,\n    TError,\n    TVariables,\n    TOnMutateResult\n  >(arg1, arg2)\n\n  const { name, ...observerOptions } = options\n\n  if (!name) warnMissingName('createMutation')\n\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<MutationStatus>()\n  const variablesUpdated = createEvent<TVariables | undefined>()\n  const isPausedUpdated = createEvent<boolean>()\n  const finishedSuccess = createEvent<{ params: TVariables; result: TData }>()\n  const finishedFailure = createEvent<{ params: TVariables; error: TError }>()\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<MutationStatus>('idle', {\n    ...sidConfig(name, '$status'),\n  }).on(statusUpdated, (_, v) => v)\n  const $variables = createStore<TVariables | undefined>(undefined, {\n    skipVoid: false,\n    ...sidConfig(name, '$variables'),\n  }).on(variablesUpdated, (_, v) => v)\n  const $isPaused = createStore(false, {\n    ...sidConfig(name, '$isPaused'),\n  }).on(isPausedUpdated, (_, v) => v)\n\n  // Derived stores via .map don't take sid — they recompute from $status on\n  // 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  const $isIdle = $status.map((s) => s === 'idle')\n\n  // Per-scope observer — same pattern as createBaseQuery. Each fork scope\n  // gets its own MutationObserver bound to its scope's QueryClient.\n  type Observer = MutationObserver<TData, TError, TVariables, TOnMutateResult>\n  const $observer = createStore<Observer | null>(null, {\n    serialize: 'ignore',\n  })\n  const observerCreated = createEvent<Observer>()\n  $observer.on(observerCreated, (_, obs) => obs)\n\n  const observerSubscriptions = new WeakMap<Observer, () => void>()\n\n  const start = createEvent<void>()\n  const unmounted = createEvent<void>()\n\n  const startFx = attach({\n    source: { qc: $effectiveClient, observer: $observer },\n    effect: ({ qc, observer: existingObserver }) => {\n      if (!qc) {\n        throw new Error(\n          '[@tanstack/query-effector] No QueryClient is set for createMutation. Call setQueryClient(qc) before start, ' +\n            'pass it to fork({ values: [[$queryClient, qc]] }), or pass it explicitly to the factory.',\n        )\n      }\n\n      const observer =\n        existingObserver ??\n        new MutationObserver<TData, TError, TVariables, TOnMutateResult>(\n          qc,\n          observerOptions,\n        )\n\n      const dispatchData = scopeBind(dataUpdated, { safe: true })\n      const dispatchError = scopeBind(errorUpdated, { safe: true })\n      const dispatchStatus = scopeBind(statusUpdated, { safe: true })\n      const dispatchVariables = scopeBind(variablesUpdated, { safe: true })\n      const dispatchIsPaused = scopeBind(isPausedUpdated, { safe: true })\n      const dispatchFinishedSuccess = scopeBind(finishedSuccess, { safe: true })\n      const dispatchFinishedFailure = scopeBind(finishedFailure, { safe: true })\n\n      observerSubscriptions.get(observer)?.()\n\n      // Track status transitions to emit `finished.success` / `finished.failure`\n      // exactly once per pending → terminal transition. The observer holds at\n      // most one inflight mutation at a time, so a single previous-status flag\n      // is sufficient.\n      let prevStatus: MutationStatus = 'idle'\n\n      const unsubscribe = observer.subscribe((result) => {\n        dispatchData(result.data)\n        dispatchError(result.error)\n        dispatchStatus(result.status)\n        dispatchVariables(result.variables)\n        dispatchIsPaused(result.isPaused)\n\n        if (prevStatus === 'pending') {\n          if (result.status === 'success') {\n            dispatchFinishedSuccess({\n              params: result.variables as TVariables,\n              result: result.data as TData,\n            })\n          } else if (result.status === 'error') {\n            dispatchFinishedFailure({\n              params: result.variables as TVariables,\n              error: result.error as TError,\n            })\n          }\n        }\n        prevStatus = result.status\n      })\n\n      observerSubscriptions.set(observer, unsubscribe)\n\n      return observer\n    },\n  })\n\n  sample({ clock: start, target: startFx })\n  sample({ clock: startFx.doneData, target: observerCreated })\n\n  // Mutation observers (unlike query observers) live across mount cycles —\n  // their data state survives unmount and can be observed again on re-start.\n  // Match that by keeping `$observer` populated; we only drop the\n  // subscription so listeners stop receiving updates after unmount.\n  const unmountFx = attach({\n    source: $observer,\n    effect: (observer) => {\n      if (!observer) return\n      observerSubscriptions.get(observer)?.()\n      observerSubscriptions.delete(observer)\n    },\n  })\n  sample({ clock: unmounted, target: unmountFx })\n\n  const mutate = createEvent<TVariables>()\n\n  // Fire-and-forget: don't return the promise so allSettled doesn't block\n  // (would deadlock under fake timers since observer.mutate awaits the user's\n  // mutationFn). Errors are tracked via the observer subscription which\n  // updates $error/$status and emits `finished.failure`.\n  const mutateFx = attach({\n    source: $observer,\n    effect: (observer, variables: TVariables) => {\n      if (!observer) return\n      observer.mutate(variables).catch(() => {})\n    },\n  })\n\n  sample({ clock: mutate, target: mutateFx })\n\n  // Per-call callbacks variant: forwards onSuccess/onError/onSettled to\n  // observer.mutate(vars, opts). Use this for component-local reactions\n  // that don't fit module-level `sample({ clock: finished.success })` wiring.\n  const mutateWith = createEvent<{\n    variables: TVariables\n    onSuccess?: MutateOptions<TData, TError, TVariables>['onSuccess']\n    onError?: MutateOptions<TData, TError, TVariables>['onError']\n    onSettled?: MutateOptions<TData, TError, TVariables>['onSettled']\n  }>()\n\n  const mutateWithFx = attach({\n    source: $observer,\n    effect: (\n      observer,\n      {\n        variables,\n        ...callbacks\n      }: {\n        variables: TVariables\n        onSuccess?: MutateOptions<TData, TError, TVariables>['onSuccess']\n        onError?: MutateOptions<TData, TError, TVariables>['onError']\n        onSettled?: MutateOptions<TData, TError, TVariables>['onSettled']\n      },\n    ) => {\n      if (!observer) return\n      observer.mutate(variables, callbacks).catch(() => {})\n    },\n  })\n\n  sample({ clock: mutateWith, target: mutateWithFx })\n\n  const reset = createEvent<void>()\n\n  const resetFx = attach({\n    source: $observer,\n    effect: (observer) => {\n      if (!observer) return\n      observer.reset()\n    },\n  })\n\n  sample({ clock: reset, target: resetFx })\n\n  return {\n    $data,\n    $error,\n    $status,\n    $variables,\n    $isPaused,\n    $isPending,\n    $isSuccess,\n    $isError,\n    $isIdle,\n    $observer,\n    $queryClient: $effectiveClient,\n    mutate,\n    mutateWith,\n    reset,\n    start,\n    unmounted,\n    finished: {\n      success: finishedSuccess,\n      failure: finishedFailure,\n    },\n  }\n}\n\nfunction parseMutationArgs<TData, TError, TVariables, TOnMutateResult>(\n  arg1:\n    | QueryClient\n    | CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n  arg2?: CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n): [\n  QueryClient | null,\n  CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n] {\n  if (arg2 !== undefined) {\n    return [arg1 as QueryClient, arg2]\n  }\n  return [\n    null,\n    arg1 as CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n  ]\n}\n"]}

package/dist/createMutation.d.cts

@@ -0,0 +1,7 @@
+import { QueryClient } from '@tanstack/query-core';
+import { CreateMutationOptions, MutationResult } from './types.cjs';
+import 'effector';
+
+declare function createMutation<TData = unknown, TError = Error, TVariables = void, TOnMutateResult = unknown>(arg1: QueryClient | CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, arg2?: CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>): MutationResult<TData, TError, TVariables>;
+
+export { createMutation };