@effector-tanstack-query/core 0.1.0

package/dist/resolve.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var effector = require('effector');
+
+// src/resolve.ts
+function resolveKey(key) {
+  const storePositions = [];
+  const stores = [];
+  key.forEach((item, i) => {
+    if (effector.is.store(item)) {
+      storePositions.push(i);
+      stores.push(item);
+    }
+  });
+  if (stores.length === 0) {
+    return effector.createStore(key);
+  }
+  return effector.combine(stores).map(
+    (values) => key.map((item, i) => {
+      const storeIdx = storePositions.indexOf(i);
+      return storeIdx >= 0 ? values[storeIdx] : item;
+    })
+  );
+}
+function resolveEnabled(enabled) {
+  if (effector.is.store(enabled)) return enabled;
+  return effector.createStore(enabled ?? true);
+}
+function resolveReactiveRefetchInterval(value) {
+  return effector.is.store(value) ? value : void 0;
+}
+
+exports.resolveEnabled = resolveEnabled;
+exports.resolveKey = resolveKey;
+exports.resolveReactiveRefetchInterval = resolveReactiveRefetchInterval;
+//# sourceMappingURL=resolve.cjs.map
+//# sourceMappingURL=resolve.cjs.map

package/dist/resolve.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/resolve.ts"],"names":["is","createStore","combine"],"mappings":";;;;;AAKO,SAAS,WAAW,GAAA,EAAwC;AACjE,EAAA,MAAM,iBAAgC,EAAC;AACvC,EAAA,MAAM,SAAgC,EAAC;AAEvC,EAAA,GAAA,CAAI,OAAA,CAAQ,CAAC,IAAA,EAAM,CAAA,KAAM;AACvB,IAAA,IAAIA,WAAA,CAAG,KAAA,CAAM,IAAI,CAAA,EAAG;AAClB,MAAA,cAAA,CAAe,KAAK,CAAC,CAAA;AACrB,MAAA,MAAA,CAAO,KAAK,IAAsB,CAAA;AAAA,IACpC;AAAA,EACF,CAAC,CAAA;AAED,EAAA,IAAI,MAAA,CAAO,WAAW,CAAA,EAAG;AACvB,IAAA,OAAOC,qBAAY,GAAe,CAAA;AAAA,EACpC;AAEA,EAAA,OAAOC,gBAAA,CAAQ,MAAM,CAAA,CAAE,GAAA;AAAA,IAAI,CAAC,MAAA,KAC1B,GAAA,CAAI,GAAA,CAAI,CAAC,MAAM,CAAA,KAAM;AACnB,MAAA,MAAM,QAAA,GAAW,cAAA,CAAe,OAAA,CAAQ,CAAC,CAAA;AACzC,MAAA,OAAO,QAAA,IAAY,CAAA,GAAI,MAAA,CAAO,QAAQ,CAAA,GAAI,IAAA;AAAA,IAC5C,CAAC;AAAA,GACH;AACF;AAEO,SAAS,eACd,OAAA,EACgB;AAChB,EAAA,IAAIF,WAAA,CAAG,KAAA,CAAM,OAAO,CAAA,EAAG,OAAO,OAAA;AAC9B,EAAA,OAAOC,oBAAA,CAAY,WAAW,IAAI,CAAA;AACpC;AAUO,SAAS,+BACd,KAAA,EAC+C;AAC/C,EAAA,OAAOD,WAAA,CAAG,KAAA,CAAM,KAAK,CAAA,GAChB,KAAA,GACD,MAAA;AACN","file":"resolve.cjs","sourcesContent":["import { combine, createStore, is } from 'effector'\nimport type { Store } from 'effector'\nimport type { QueryKey } from '@tanstack/query-core'\nimport type { EffectorQueryKey, StoreOrValue } from './types'\n\nexport function resolveKey(key: EffectorQueryKey): Store<QueryKey> {\n  const storePositions: Array<number> = []\n  const stores: Array<Store<unknown>> = []\n\n  key.forEach((item, i) => {\n    if (is.store(item)) {\n      storePositions.push(i)\n      stores.push(item as Store<unknown>)\n    }\n  })\n\n  if (stores.length === 0) {\n    return createStore(key as QueryKey)\n  }\n\n  return combine(stores).map((values) =>\n    key.map((item, i) => {\n      const storeIdx = storePositions.indexOf(i)\n      return storeIdx >= 0 ? values[storeIdx] : item\n    }),\n  ) as Store<QueryKey>\n}\n\nexport function resolveEnabled(\n  enabled: StoreOrValue<boolean> | undefined,\n): Store<boolean> {\n  if (is.store(enabled)) return enabled\n  return createStore(enabled ?? true)\n}\n\n/**\n * `refetchInterval` accepts a static value, a function `(query) => …`, or an\n * effector `Store<number | false>`. Only the Store form is \"reactive\" — the\n * function form is evaluated by the observer on every tick and stays in the\n * observer's options. Returns the store if one was passed, `undefined`\n * otherwise (signaling the per-flavor factory to keep the value in\n * `restOptions` for the observer constructor).\n */\nexport function resolveReactiveRefetchInterval(\n  value: unknown,\n): Store<number | false | undefined> | undefined {\n  return is.store(value)\n    ? (value as Store<number | false | undefined>)\n    : undefined\n}\n"]}

package/dist/resolve.d.cts

@@ -0,0 +1,17 @@
+import { Store } from 'effector';
+import { QueryKey } from '@tanstack/query-core';
+import { StoreOrValue, EffectorQueryKey } from './types.cjs';
+
+declare function resolveKey(key: EffectorQueryKey): Store<QueryKey>;
+declare function resolveEnabled(enabled: StoreOrValue<boolean> | undefined): Store<boolean>;
+/**
+ * `refetchInterval` accepts a static value, a function `(query) => …`, or an
+ * effector `Store<number | false>`. Only the Store form is "reactive" — the
+ * function form is evaluated by the observer on every tick and stays in the
+ * observer's options. Returns the store if one was passed, `undefined`
+ * otherwise (signaling the per-flavor factory to keep the value in
+ * `restOptions` for the observer constructor).
+ */
+declare function resolveReactiveRefetchInterval(value: unknown): Store<number | false | undefined> | undefined;
+
+export { resolveEnabled, resolveKey, resolveReactiveRefetchInterval };

package/dist/resolve.d.ts

@@ -0,0 +1,17 @@
+import { Store } from 'effector';
+import { QueryKey } from '@tanstack/query-core';
+import { StoreOrValue, EffectorQueryKey } from './types.js';
+
+declare function resolveKey(key: EffectorQueryKey): Store<QueryKey>;
+declare function resolveEnabled(enabled: StoreOrValue<boolean> | undefined): Store<boolean>;
+/**
+ * `refetchInterval` accepts a static value, a function `(query) => …`, or an
+ * effector `Store<number | false>`. Only the Store form is "reactive" — the
+ * function form is evaluated by the observer on every tick and stays in the
+ * observer's options. Returns the store if one was passed, `undefined`
+ * otherwise (signaling the per-flavor factory to keep the value in
+ * `restOptions` for the observer constructor).
+ */
+declare function resolveReactiveRefetchInterval(value: unknown): Store<number | false | undefined> | undefined;
+
+export { resolveEnabled, resolveKey, resolveReactiveRefetchInterval };

package/dist/resolve.js

@@ -0,0 +1,33 @@
+import { is, createStore, combine } from 'effector';
+
+// src/resolve.ts
+function resolveKey(key) {
+  const storePositions = [];
+  const stores = [];
+  key.forEach((item, i) => {
+    if (is.store(item)) {
+      storePositions.push(i);
+      stores.push(item);
+    }
+  });
+  if (stores.length === 0) {
+    return createStore(key);
+  }
+  return combine(stores).map(
+    (values) => key.map((item, i) => {
+      const storeIdx = storePositions.indexOf(i);
+      return storeIdx >= 0 ? values[storeIdx] : item;
+    })
+  );
+}
+function resolveEnabled(enabled) {
+  if (is.store(enabled)) return enabled;
+  return createStore(enabled ?? true);
+}
+function resolveReactiveRefetchInterval(value) {
+  return is.store(value) ? value : void 0;
+}
+
+export { resolveEnabled, resolveKey, resolveReactiveRefetchInterval };
+//# sourceMappingURL=resolve.js.map
+//# sourceMappingURL=resolve.js.map

package/dist/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/resolve.ts"],"names":[],"mappings":";;;AAKO,SAAS,WAAW,GAAA,EAAwC;AACjE,EAAA,MAAM,iBAAgC,EAAC;AACvC,EAAA,MAAM,SAAgC,EAAC;AAEvC,EAAA,GAAA,CAAI,OAAA,CAAQ,CAAC,IAAA,EAAM,CAAA,KAAM;AACvB,IAAA,IAAI,EAAA,CAAG,KAAA,CAAM,IAAI,CAAA,EAAG;AAClB,MAAA,cAAA,CAAe,KAAK,CAAC,CAAA;AACrB,MAAA,MAAA,CAAO,KAAK,IAAsB,CAAA;AAAA,IACpC;AAAA,EACF,CAAC,CAAA;AAED,EAAA,IAAI,MAAA,CAAO,WAAW,CAAA,EAAG;AACvB,IAAA,OAAO,YAAY,GAAe,CAAA;AAAA,EACpC;AAEA,EAAA,OAAO,OAAA,CAAQ,MAAM,CAAA,CAAE,GAAA;AAAA,IAAI,CAAC,MAAA,KAC1B,GAAA,CAAI,GAAA,CAAI,CAAC,MAAM,CAAA,KAAM;AACnB,MAAA,MAAM,QAAA,GAAW,cAAA,CAAe,OAAA,CAAQ,CAAC,CAAA;AACzC,MAAA,OAAO,QAAA,IAAY,CAAA,GAAI,MAAA,CAAO,QAAQ,CAAA,GAAI,IAAA;AAAA,IAC5C,CAAC;AAAA,GACH;AACF;AAEO,SAAS,eACd,OAAA,EACgB;AAChB,EAAA,IAAI,EAAA,CAAG,KAAA,CAAM,OAAO,CAAA,EAAG,OAAO,OAAA;AAC9B,EAAA,OAAO,WAAA,CAAY,WAAW,IAAI,CAAA;AACpC;AAUO,SAAS,+BACd,KAAA,EAC+C;AAC/C,EAAA,OAAO,EAAA,CAAG,KAAA,CAAM,KAAK,CAAA,GAChB,KAAA,GACD,MAAA;AACN","file":"resolve.js","sourcesContent":["import { combine, createStore, is } from 'effector'\nimport type { Store } from 'effector'\nimport type { QueryKey } from '@tanstack/query-core'\nimport type { EffectorQueryKey, StoreOrValue } from './types'\n\nexport function resolveKey(key: EffectorQueryKey): Store<QueryKey> {\n  const storePositions: Array<number> = []\n  const stores: Array<Store<unknown>> = []\n\n  key.forEach((item, i) => {\n    if (is.store(item)) {\n      storePositions.push(i)\n      stores.push(item as Store<unknown>)\n    }\n  })\n\n  if (stores.length === 0) {\n    return createStore(key as QueryKey)\n  }\n\n  return combine(stores).map((values) =>\n    key.map((item, i) => {\n      const storeIdx = storePositions.indexOf(i)\n      return storeIdx >= 0 ? values[storeIdx] : item\n    }),\n  ) as Store<QueryKey>\n}\n\nexport function resolveEnabled(\n  enabled: StoreOrValue<boolean> | undefined,\n): Store<boolean> {\n  if (is.store(enabled)) return enabled\n  return createStore(enabled ?? true)\n}\n\n/**\n * `refetchInterval` accepts a static value, a function `(query) => …`, or an\n * effector `Store<number | false>`. Only the Store form is \"reactive\" — the\n * function form is evaluated by the observer on every tick and stays in the\n * observer's options. Returns the store if one was passed, `undefined`\n * otherwise (signaling the per-flavor factory to keep the value in\n * `restOptions` for the observer constructor).\n */\nexport function resolveReactiveRefetchInterval(\n  value: unknown,\n): Store<number | false | undefined> | undefined {\n  return is.store(value)\n    ? (value as Store<number | false | undefined>)\n    : undefined\n}\n"]}

package/dist/types.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=types.cjs.map
+//# sourceMappingURL=types.cjs.map

package/dist/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"types.cjs"}

package/dist/types.d.cts

@@ -0,0 +1,209 @@
+import { Store, EventCallable, Event } from 'effector';
+import { InfiniteData, InfiniteQueryObserverOptions, QueryStatus, FetchStatus, InfiniteQueryObserver, QueryKey, QueryClient, MutationObserverOptions, MutationObserver, MutateOptions, QueryObserverOptions, QueryObserver } from '@tanstack/query-core';
+
+type StoreOrValue<T> = Store<T> | T;
+/**
+ * A query key where each element can be a plain value or an effector Store.
+ * When any Store changes, the query is automatically re-executed with the new key.
+ *
+ * @example
+ * const $userId = createStore(1)
+ * queryKey: ['user', $userId, 'details']
+ */
+type EffectorQueryKey = ReadonlyArray<StoreOrValue<string | number | bigint | boolean | null | undefined | object>>;
+interface CreateQueryOptions<TQueryFnData = unknown, TError = Error, TData = TQueryFnData> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData>, 'queryKey' | 'enabled' | 'refetchInterval'> {
+    queryKey: EffectorQueryKey;
+    enabled?: StoreOrValue<boolean>;
+    /**
+     * Polling interval in milliseconds, `false` to disable, or a Store for
+     * runtime toggling — `Store<number | false>`. When a Store is passed, the
+     * observer's `refetchInterval` is automatically kept in sync via
+     * `setOptions` on every store change. The function form (`(query) => …`)
+     * from TanStack Query is also still supported.
+     */
+    refetchInterval?: QueryObserverOptions<TQueryFnData, TError, TData>['refetchInterval'] | Store<number | false | undefined>;
+    /**
+     * Stable name used to derive SIDs for the internal effector stores so that
+     * `serialize(scope)` / `fork({ values })` round-trip works for SSR. Without
+     * a name, the queryClient's `dehydrate`/`hydrate` path still works, but
+     * scope-only serialization will silently drop these stores.
+     */
+    name?: string;
+}
+interface QueryResult<TData, TError = Error> {
+    /** The resolved query data, or `undefined` while loading */
+    $data: Store<TData | undefined>;
+    /** The query error, or `null` if there is none */
+    $error: Store<TError | null>;
+    /** The query status: `'pending'` | `'success'` | `'error'` */
+    $status: Store<QueryStatus>;
+    /** `true` while there is no cached data and the query is fetching */
+    $isPending: Store<boolean>;
+    /** `true` while the query is fetching in the background */
+    $isFetching: Store<boolean>;
+    /** `true` when the query has successfully fetched data */
+    $isSuccess: Store<boolean>;
+    /** `true` when the query has failed */
+    $isError: Store<boolean>;
+    /** `true` when the displayed data is placeholder data (not yet fetched for current key) */
+    $isPlaceholderData: Store<boolean>;
+    /** The fetch status: `'fetching'` | `'paused'` | `'idle'` */
+    $fetchStatus: Store<FetchStatus>;
+    /** Invalidates the query and triggers a background refetch */
+    refresh: EventCallable<void>;
+    /**
+     * Fetches the query via `queryClient.fetchQuery` and **awaits** the result.
+     * Unlike `mounted`, this is meant for server-side prefetching / route
+     * loaders where you need the cache populated before responding to the
+     * request — `await allSettled(query.prefetch, { scope })` returns only
+     * after the queryFn has resolved. Skips automatically when `enabled` is
+     * `false`.
+     *
+     * @example
+     * await allSettled(query.prefetch, { scope })
+     * // queryClient cache + scope are now ready to be dehydrated/serialized.
+     */
+    prefetch: EventCallable<void>;
+    /**
+     * Initializes the query subscription. Must be called (or used with allSettled)
+     * before the query starts fetching.
+     *
+     * @example Without fork
+     * query.mounted()
+     *
+     * @example With fork (test isolation)
+     * const scope = fork()
+     * await allSettled(query.mounted, { scope })
+     */
+    mounted: EventCallable<void>;
+    /**
+     * Tears down the query subscription and cancels any in-flight request.
+     * Call this when the consumer is destroyed (e.g. component unmount).
+     */
+    unmounted: EventCallable<void>;
+    /**
+     * Per-scope observer store. Each fork scope has its own Observer instance,
+     * created lazily on `mounted()` and bound to that scope's QueryClient.
+     * Read scope-aware via `useUnit($observer)`. For tests, prefer
+     * `scope.getState($observer)` over reading the default scope state.
+     */
+    $observer: Store<QueryObserver<TData, TError> | null>;
+    /**
+     * The QueryClient store this query is bound to. Frozen if a client was
+     * passed explicitly to the factory; otherwise points at the global
+     * `$queryClient` and honors `fork({ values: [[$queryClient, qc]] })`.
+     */
+    $queryClient: Store<QueryClient | null>;
+}
+interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = Error, TPageParam = unknown, TData = InfiniteData<TQueryFnData, TPageParam>> extends Omit<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, ReadonlyArray<unknown>, TPageParam>, 'queryKey' | 'enabled' | 'refetchInterval'> {
+    queryKey: EffectorQueryKey;
+    enabled?: StoreOrValue<boolean>;
+    /** See {@link CreateQueryOptions.refetchInterval}. */
+    refetchInterval?: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, ReadonlyArray<unknown>, TPageParam>['refetchInterval'] | Store<number | false | undefined>;
+    /** See {@link CreateQueryOptions.name}. */
+    name?: string;
+}
+interface InfiniteQueryResult<TData, TError = Error, TPageParam = unknown> {
+    /**
+     * The selected/displayed data. Defaults to `InfiniteData<TQueryFnData, TPageParam>`
+     * but narrows to whatever `select` returns when provided.
+     */
+    $data: Store<TData | undefined>;
+    $error: Store<TError | null>;
+    $status: Store<QueryStatus>;
+    $isPending: Store<boolean>;
+    $isFetching: Store<boolean>;
+    $isSuccess: Store<boolean>;
+    $isError: Store<boolean>;
+    $isPlaceholderData: Store<boolean>;
+    $fetchStatus: Store<FetchStatus>;
+    $hasNextPage: Store<boolean>;
+    $hasPreviousPage: Store<boolean>;
+    $isFetchingNextPage: Store<boolean>;
+    $isFetchingPreviousPage: Store<boolean>;
+    $isFetchNextPageError: Store<boolean>;
+    $isFetchPreviousPageError: Store<boolean>;
+    fetchNextPage: EventCallable<void>;
+    fetchPreviousPage: EventCallable<void>;
+    refresh: EventCallable<void>;
+    /** See {@link QueryResult.prefetch}. Uses `fetchInfiniteQuery` under the hood. */
+    prefetch: EventCallable<void>;
+    mounted: EventCallable<void>;
+    unmounted: EventCallable<void>;
+    /** See {@link QueryResult.$observer}. */
+    $observer: Store<InfiniteQueryObserver<any, TError, TData, QueryKey, TPageParam> | null>;
+    /** See {@link QueryResult.$queryClient}. */
+    $queryClient: Store<QueryClient | null>;
+}
+type CreateMutationOptions<TData = unknown, TError = Error, TVariables = void, TOnMutateResult = unknown> = MutationObserverOptions<TData, TError, TVariables, TOnMutateResult> & {
+    /** See {@link CreateQueryOptions.name}. */
+    name?: string;
+};
+type MutationStatus = 'idle' | 'pending' | 'success' | 'error';
+interface MutationResult<TData = unknown, TError = Error, TVariables = void> {
+    /** The mutation result data, or `undefined` before success */
+    $data: Store<TData | undefined>;
+    /** The mutation error, or `null` if there is none */
+    $error: Store<TError | null>;
+    /** The mutation status: `'idle'` | `'pending'` | `'success'` | `'error'` */
+    $status: Store<MutationStatus>;
+    /** The variables passed to the last `mutate` call */
+    $variables: Store<TVariables | undefined>;
+    /** `true` while the mutation is paused (e.g. offline) and cannot run */
+    $isPaused: Store<boolean>;
+    /** `true` while the mutation is executing */
+    $isPending: Store<boolean>;
+    /** `true` when the mutation has succeeded */
+    $isSuccess: Store<boolean>;
+    /** `true` when the mutation has failed */
+    $isError: Store<boolean>;
+    /** `true` when the mutation has not yet been triggered */
+    $isIdle: Store<boolean>;
+    /** Per-scope MutationObserver. Created on `start()`. See {@link QueryResult.$observer}. */
+    $observer: Store<MutationObserver<TData, TError, TVariables, any> | null>;
+    /** See {@link QueryResult.$queryClient}. */
+    $queryClient: Store<QueryClient | null>;
+    /** Triggers the mutation with the given variables */
+    mutate: EventCallable<TVariables>;
+    /**
+     * Triggers the mutation with per-call callbacks layered on top of the
+     * observer-level ones. Use when you need component-local reactions
+     * (e.g. navigate after success) without module-level `sample` wiring.
+     */
+    mutateWith: EventCallable<{
+        variables: TVariables;
+        onSuccess?: MutateOptions<TData, TError, TVariables>['onSuccess'];
+        onError?: MutateOptions<TData, TError, TVariables>['onError'];
+        onSettled?: MutateOptions<TData, TError, TVariables>['onSettled'];
+    }>;
+    /** Resets the mutation state back to idle */
+    reset: EventCallable<void>;
+    /**
+     * Initializes the mutation observer subscription.
+     * Must be called before mutate to ensure stores receive updates.
+     */
+    start: EventCallable<void>;
+    /**
+     * Tears down the observer subscription. Call this when the consumer is
+     * destroyed (e.g. component unmount) so the queryClient can gc the
+     * mutation entry.
+     */
+    unmounted: EventCallable<void>;
+    /**
+     * Sample-friendly events for module-level reactions to mutation outcome.
+     * Payloads include both the original `params` and the `result` / `error`,
+     * matching effector effect `done` / `fail` shape.
+     */
+    finished: {
+        success: Event<{
+            params: TVariables;
+            result: TData;
+        }>;
+        failure: Event<{
+            params: TVariables;
+            error: TError;
+        }>;
+    };
+}
+
+export type { CreateInfiniteQueryOptions, CreateMutationOptions, CreateQueryOptions, EffectorQueryKey, InfiniteQueryResult, MutationResult, MutationStatus, QueryResult, StoreOrValue };

package/dist/types.d.ts

@@ -0,0 +1,209 @@
+import { Store, EventCallable, Event } from 'effector';
+import { InfiniteData, InfiniteQueryObserverOptions, QueryStatus, FetchStatus, InfiniteQueryObserver, QueryKey, QueryClient, MutationObserverOptions, MutationObserver, MutateOptions, QueryObserverOptions, QueryObserver } from '@tanstack/query-core';
+
+type StoreOrValue<T> = Store<T> | T;
+/**
+ * A query key where each element can be a plain value or an effector Store.
+ * When any Store changes, the query is automatically re-executed with the new key.
+ *
+ * @example
+ * const $userId = createStore(1)
+ * queryKey: ['user', $userId, 'details']
+ */
+type EffectorQueryKey = ReadonlyArray<StoreOrValue<string | number | bigint | boolean | null | undefined | object>>;
+interface CreateQueryOptions<TQueryFnData = unknown, TError = Error, TData = TQueryFnData> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData>, 'queryKey' | 'enabled' | 'refetchInterval'> {
+    queryKey: EffectorQueryKey;
+    enabled?: StoreOrValue<boolean>;
+    /**
+     * Polling interval in milliseconds, `false` to disable, or a Store for
+     * runtime toggling — `Store<number | false>`. When a Store is passed, the
+     * observer's `refetchInterval` is automatically kept in sync via
+     * `setOptions` on every store change. The function form (`(query) => …`)
+     * from TanStack Query is also still supported.
+     */
+    refetchInterval?: QueryObserverOptions<TQueryFnData, TError, TData>['refetchInterval'] | Store<number | false | undefined>;
+    /**
+     * Stable name used to derive SIDs for the internal effector stores so that
+     * `serialize(scope)` / `fork({ values })` round-trip works for SSR. Without
+     * a name, the queryClient's `dehydrate`/`hydrate` path still works, but
+     * scope-only serialization will silently drop these stores.
+     */
+    name?: string;
+}
+interface QueryResult<TData, TError = Error> {
+    /** The resolved query data, or `undefined` while loading */
+    $data: Store<TData | undefined>;
+    /** The query error, or `null` if there is none */
+    $error: Store<TError | null>;
+    /** The query status: `'pending'` | `'success'` | `'error'` */
+    $status: Store<QueryStatus>;
+    /** `true` while there is no cached data and the query is fetching */
+    $isPending: Store<boolean>;
+    /** `true` while the query is fetching in the background */
+    $isFetching: Store<boolean>;
+    /** `true` when the query has successfully fetched data */
+    $isSuccess: Store<boolean>;
+    /** `true` when the query has failed */
+    $isError: Store<boolean>;
+    /** `true` when the displayed data is placeholder data (not yet fetched for current key) */
+    $isPlaceholderData: Store<boolean>;
+    /** The fetch status: `'fetching'` | `'paused'` | `'idle'` */
+    $fetchStatus: Store<FetchStatus>;
+    /** Invalidates the query and triggers a background refetch */
+    refresh: EventCallable<void>;
+    /**
+     * Fetches the query via `queryClient.fetchQuery` and **awaits** the result.
+     * Unlike `mounted`, this is meant for server-side prefetching / route
+     * loaders where you need the cache populated before responding to the
+     * request — `await allSettled(query.prefetch, { scope })` returns only
+     * after the queryFn has resolved. Skips automatically when `enabled` is
+     * `false`.
+     *
+     * @example
+     * await allSettled(query.prefetch, { scope })
+     * // queryClient cache + scope are now ready to be dehydrated/serialized.
+     */
+    prefetch: EventCallable<void>;
+    /**
+     * Initializes the query subscription. Must be called (or used with allSettled)
+     * before the query starts fetching.
+     *
+     * @example Without fork
+     * query.mounted()
+     *
+     * @example With fork (test isolation)
+     * const scope = fork()
+     * await allSettled(query.mounted, { scope })
+     */
+    mounted: EventCallable<void>;
+    /**
+     * Tears down the query subscription and cancels any in-flight request.
+     * Call this when the consumer is destroyed (e.g. component unmount).
+     */
+    unmounted: EventCallable<void>;
+    /**
+     * Per-scope observer store. Each fork scope has its own Observer instance,
+     * created lazily on `mounted()` and bound to that scope's QueryClient.
+     * Read scope-aware via `useUnit($observer)`. For tests, prefer
+     * `scope.getState($observer)` over reading the default scope state.
+     */
+    $observer: Store<QueryObserver<TData, TError> | null>;
+    /**
+     * The QueryClient store this query is bound to. Frozen if a client was
+     * passed explicitly to the factory; otherwise points at the global
+     * `$queryClient` and honors `fork({ values: [[$queryClient, qc]] })`.
+     */
+    $queryClient: Store<QueryClient | null>;
+}
+interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = Error, TPageParam = unknown, TData = InfiniteData<TQueryFnData, TPageParam>> extends Omit<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, ReadonlyArray<unknown>, TPageParam>, 'queryKey' | 'enabled' | 'refetchInterval'> {
+    queryKey: EffectorQueryKey;
+    enabled?: StoreOrValue<boolean>;
+    /** See {@link CreateQueryOptions.refetchInterval}. */
+    refetchInterval?: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, ReadonlyArray<unknown>, TPageParam>['refetchInterval'] | Store<number | false | undefined>;
+    /** See {@link CreateQueryOptions.name}. */
+    name?: string;
+}
+interface InfiniteQueryResult<TData, TError = Error, TPageParam = unknown> {
+    /**
+     * The selected/displayed data. Defaults to `InfiniteData<TQueryFnData, TPageParam>`
+     * but narrows to whatever `select` returns when provided.
+     */
+    $data: Store<TData | undefined>;
+    $error: Store<TError | null>;
+    $status: Store<QueryStatus>;
+    $isPending: Store<boolean>;
+    $isFetching: Store<boolean>;
+    $isSuccess: Store<boolean>;
+    $isError: Store<boolean>;
+    $isPlaceholderData: Store<boolean>;
+    $fetchStatus: Store<FetchStatus>;
+    $hasNextPage: Store<boolean>;
+    $hasPreviousPage: Store<boolean>;
+    $isFetchingNextPage: Store<boolean>;
+    $isFetchingPreviousPage: Store<boolean>;
+    $isFetchNextPageError: Store<boolean>;
+    $isFetchPreviousPageError: Store<boolean>;
+    fetchNextPage: EventCallable<void>;
+    fetchPreviousPage: EventCallable<void>;
+    refresh: EventCallable<void>;
+    /** See {@link QueryResult.prefetch}. Uses `fetchInfiniteQuery` under the hood. */
+    prefetch: EventCallable<void>;
+    mounted: EventCallable<void>;
+    unmounted: EventCallable<void>;
+    /** See {@link QueryResult.$observer}. */
+    $observer: Store<InfiniteQueryObserver<any, TError, TData, QueryKey, TPageParam> | null>;
+    /** See {@link QueryResult.$queryClient}. */
+    $queryClient: Store<QueryClient | null>;
+}
+type CreateMutationOptions<TData = unknown, TError = Error, TVariables = void, TOnMutateResult = unknown> = MutationObserverOptions<TData, TError, TVariables, TOnMutateResult> & {
+    /** See {@link CreateQueryOptions.name}. */
+    name?: string;
+};
+type MutationStatus = 'idle' | 'pending' | 'success' | 'error';
+interface MutationResult<TData = unknown, TError = Error, TVariables = void> {
+    /** The mutation result data, or `undefined` before success */
+    $data: Store<TData | undefined>;
+    /** The mutation error, or `null` if there is none */
+    $error: Store<TError | null>;
+    /** The mutation status: `'idle'` | `'pending'` | `'success'` | `'error'` */
+    $status: Store<MutationStatus>;
+    /** The variables passed to the last `mutate` call */
+    $variables: Store<TVariables | undefined>;
+    /** `true` while the mutation is paused (e.g. offline) and cannot run */
+    $isPaused: Store<boolean>;
+    /** `true` while the mutation is executing */
+    $isPending: Store<boolean>;
+    /** `true` when the mutation has succeeded */
+    $isSuccess: Store<boolean>;
+    /** `true` when the mutation has failed */
+    $isError: Store<boolean>;
+    /** `true` when the mutation has not yet been triggered */
+    $isIdle: Store<boolean>;
+    /** Per-scope MutationObserver. Created on `start()`. See {@link QueryResult.$observer}. */
+    $observer: Store<MutationObserver<TData, TError, TVariables, any> | null>;
+    /** See {@link QueryResult.$queryClient}. */
+    $queryClient: Store<QueryClient | null>;
+    /** Triggers the mutation with the given variables */
+    mutate: EventCallable<TVariables>;
+    /**
+     * Triggers the mutation with per-call callbacks layered on top of the
+     * observer-level ones. Use when you need component-local reactions
+     * (e.g. navigate after success) without module-level `sample` wiring.
+     */
+    mutateWith: EventCallable<{
+        variables: TVariables;
+        onSuccess?: MutateOptions<TData, TError, TVariables>['onSuccess'];
+        onError?: MutateOptions<TData, TError, TVariables>['onError'];
+        onSettled?: MutateOptions<TData, TError, TVariables>['onSettled'];
+    }>;
+    /** Resets the mutation state back to idle */
+    reset: EventCallable<void>;
+    /**
+     * Initializes the mutation observer subscription.
+     * Must be called before mutate to ensure stores receive updates.
+     */
+    start: EventCallable<void>;
+    /**
+     * Tears down the observer subscription. Call this when the consumer is
+     * destroyed (e.g. component unmount) so the queryClient can gc the
+     * mutation entry.
+     */
+    unmounted: EventCallable<void>;
+    /**
+     * Sample-friendly events for module-level reactions to mutation outcome.
+     * Payloads include both the original `params` and the `result` / `error`,
+     * matching effector effect `done` / `fail` shape.
+     */
+    finished: {
+        success: Event<{
+            params: TVariables;
+            result: TData;
+        }>;
+        failure: Event<{
+            params: TVariables;
+            error: TError;
+        }>;
+    };
+}
+
+export type { CreateInfiniteQueryOptions, CreateMutationOptions, CreateQueryOptions, EffectorQueryKey, InfiniteQueryResult, MutationResult, MutationStatus, QueryResult, StoreOrValue };

package/dist/types.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"types.js"}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@effector-tanstack-query/core",
+  "version": "0.1.0",
+  "description": "Effector bindings for TanStack Query — core factories (createQuery, createMutation, createInfiniteQuery)",
+  "license": "MIT",
+  "author": "Ilya Agarkov <ilya.al.ag@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ilyaagarkov/effector-tanstack-query.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/ilyaagarkov/effector-tanstack-query#readme",
+  "bugs": {
+    "url": "https://github.com/ilyaagarkov/effector-tanstack-query/issues"
+  },
+  "keywords": [
+    "effector",
+    "tanstack",
+    "query",
+    "data-fetching",
+    "ssr"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/__tests__"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "clean": "rm -rf ./dist ./coverage",
+    "test": "vitest --run",
+    "test:watch": "vitest",
+    "test:types": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@tanstack/query-core": "^5.0.0"
+  },
+  "peerDependencies": {
+    "effector": ">=23.0.0"
+  }
+}