@fozy-labs/rx-toolkit 0.5.3-rc.2 → 0.5.3

package/dist/query/index.js

@@ -1,13 +1,14 @@
 // Command API
-export * from './api/createCommand';
-export * from './react/useCommandAgent';
+export * from "./api/createCommand";
+export * from "./react/useCommandAgent";
 // Resource API
-export * from './api/createResource';
-export * from './api/createResourceDuplicator';
-export * from './api/resetAllQueriesCache';
-export * from './SKIP_TOKEN';
-export * from './react/useResourceAgent';
-export * from './react/useResourceRef';
+export * from "./api/createResource";
+export * from "./api/createResourceDuplicator";
+export * from "./api/resetAllQueriesCache";
+export * from "./SKIP_TOKEN";
+export * from "./types";
+export * from "./react/useResourceAgent";
+export * from "./react/useResourceRef";
 // Deprecated Operation API (backward compatibility)
-export * from './api/createOperation';
-export * from './react/useOperationAgent';
+export * from "./api/createOperation";
+export * from "./react/useOperationAgent";

package/dist/query/lib/IndirectMap.js

@@ -22,7 +22,7 @@ export class IndirectMap {
     get(key) {
         const item = this._map.get(key);
         if (!item) {
-            const isObject = typeof key === 'object' && key !== null;
+            const isObject = typeof key === "object" && key !== null;
             if (!isObject) {
                 return undefined;
             }
@@ -40,7 +40,7 @@ export class IndirectMap {
             this._map.set(key, value);
         }
         else {
-            const isObject = typeof key === 'object' && key !== null;
+            const isObject = typeof key === "object" && key !== null;
             if (!isObject) {
                 this._map.set(key, value);
                 return;
@@ -61,7 +61,7 @@ export class IndirectMap {
      * @param key
      */
     delete(key) {
-        const isObject = typeof key === 'object' && key !== null;
+        const isObject = typeof key === "object" && key !== null;
         if (isObject) {
             const cachedKey = this._getCachedKey(key);
             if (cachedKey) {
@@ -73,7 +73,7 @@ export class IndirectMap {
     }
     has(key) {
         const has = this._map.has(key);
-        if (!has && typeof key === 'object' && key !== null) {
+        if (!has && typeof key === "object" && key !== null) {
             const cachedKey = this._getCachedKey(key);
             if (!cachedKey) {
                 return false;

package/dist/query/react/useCommandAgent.d.ts

@@ -1,8 +1,8 @@
-import type { Prettify, CommandAgentInstance, CommandDefinition, CommandQueryState } from "../../query/types";
+import type { CommandAgentInstance, CommandDefinition, CommandQueryState, Prettify } from "../../query/types";
 type WithAgent<D extends CommandDefinition> = {
     createAgent: () => CommandAgentInstance<D>;
 };
-type TriggerFn<D extends CommandDefinition> = (args: D['Args']) => Promise<D['Data']>;
+type TriggerFn<D extends CommandDefinition> = (args: D["Args"]) => Promise<D["Data"]>;
 type Result<D extends CommandDefinition> = [TriggerFn<D>, Prettify<CommandQueryState<D>>];
 /**
  * React hook для работы с командой (Command).

package/dist/query/react/useOperationAgent.d.ts

@@ -1,4 +1,4 @@
-import { useCommandAgent } from './useCommandAgent';
+import { useCommandAgent } from "./useCommandAgent";
 /**
  * @deprecated Use `useCommandAgent` instead. Will be removed in v0.6.0.
  * @see useCommandAgent

package/dist/query/react/useOperationAgent.js

@@ -1,4 +1,4 @@
-import { useCommandAgent } from './useCommandAgent';
+import { useCommandAgent } from "./useCommandAgent";
 /**
  * @deprecated Use `useCommandAgent` instead. Will be removed in v0.6.0.
  * @see useCommandAgent

package/dist/query/react/useResourceAgent.d.ts

@@ -1,6 +1,6 @@
-import { Prettify, ResourceDefinition, ResourceInstance, ResourceQueryState } from "../../query/types";
-import { SKIP } from "../../query/SKIP_TOKEN";
 import { DuplicatorDefinition, ResourceDuplicator } from "../../query/core/Resource/ResourceDuplicator";
+import { SKIP } from "../../query/SKIP_TOKEN";
+import { Prettify, ResourceDefinition, ResourceInstance, ResourceQueryState } from "../../query/types";
 type Result<D extends ResourceDefinition> = Prettify<ResourceQueryState<D>>;
-export declare function useResourceAgent<D extends ResourceDefinition>(res: ResourceInstance<D> | ResourceDuplicator<DuplicatorDefinition<D>>, ...argss: D['Args'] extends void ? [] | [typeof SKIP] : [D['Args'] | typeof SKIP]): Result<D>;
+export declare function useResourceAgent<D extends ResourceDefinition>(res: ResourceInstance<D> | ResourceDuplicator<DuplicatorDefinition<D>>, ...argss: D["Args"] extends void ? [] | [typeof SKIP] : [D["Args"] | typeof SKIP]): Result<D>;
 export {};

package/dist/query/react/useResourceAgent.js

@@ -1,7 +1,7 @@
 import React from "react";
 import { useConstant } from "../../common/react";
-import { useSignal } from "../../signals/react";
 import { SKIP } from "../../query/SKIP_TOKEN";
+import { useSignal } from "../../signals/react";
 export function useResourceAgent(res, ...argss) {
     const args = (argss[0] === SKIP ? SKIP : argss[0]);
     const prevArgsRef = React.useRef(SKIP);

package/dist/query/react/useResourceRef.d.ts

@@ -1,5 +1,5 @@
 import { SKIP } from "../../query/SKIP_TOKEN";
-import type { Prettify, ResourceDefinition, ResourceInstance, ResourceRefInstanse } from "../../query/types";
-type Result<D extends ResourceDefinition> = Prettify<ResourceRefInstanse<D>>;
-export declare function useResourceRef<D extends ResourceDefinition>(res: ResourceInstance<D>, ...argss: D['Args'] extends void ? [] | [typeof SKIP] : [D['Args'] | typeof SKIP]): Result<D>;
+import type { Prettify, ResourceDefinition, ResourceInstance, ResourceRefInstance } from "../../query/types";
+type Result<D extends ResourceDefinition> = Prettify<ResourceRefInstance<D>>;
+export declare function useResourceRef<D extends ResourceDefinition>(res: ResourceInstance<D>, ...argss: D["Args"] extends void ? [] | [typeof SKIP] : [D["Args"] | typeof SKIP]): Result<D>;
 export {};

package/dist/query/react/useResourceRef.js

@@ -1,8 +1,13 @@
 import React from "react";
+import { shallowEqual } from "../../common/utils/shallowEqual";
 import { SKIP } from "../../query/SKIP_TOKEN";
 export function useResourceRef(res, ...argss) {
     const args = (argss[0] === SKIP ? SKIP : argss[0]);
+    const stableArgsRef = React.useRef(args);
+    if (!shallowEqual(stableArgsRef.current, args)) {
+        stableArgsRef.current = args;
+    }
     return React.useMemo(() => {
-        return res.createRef(args);
-    }, [args]);
+        return res.createRef(stableArgsRef.current);
+    }, [stableArgsRef.current]);
 }

package/dist/query/types/Command.types.d.ts

@@ -1,6 +1,6 @@
 import { ReadableSignalLike } from "../../signals/types";
-import { FallbackOnNever, OnCacheEntryAdded, OnQueryStarted } from "./shared.types";
 import { ResourceDefinition, ResourceInstance } from "./Resource.types";
+import { FallbackOnNever, OnCacheEntryAdded, OnQueryStarted } from "./shared.types";
 /**
  * Функция создания команды
  */

package/dist/query/types/Operation.types.d.ts

@@ -1,4 +1,4 @@
-import { CommandCreateFn, CommandCreateOptions, CommandDefinition, CommandInstance, CommandAgentInstance, CommandQueryState } from './Command.types';
+import { CommandAgentInstance, CommandCreateFn, CommandCreateOptions, CommandDefinition, CommandInstance, CommandQueryState } from "./Command.types";
 /** @deprecated Use `CommandCreateFn` instead. Will be removed in v0.6.0. */
 export type OperationCreateFn<ARGS, RESULT, SELECTED = never> = CommandCreateFn<ARGS, RESULT, SELECTED>;
 /** @deprecated Use `CommandCreateOptions` instead. Will be removed in v0.6.0. */

package/dist/query/types/Resource.types.d.ts

@@ -61,7 +61,7 @@ export type ResourceInstance<D extends ResourceDefinition> = {
     /** Создает агента для работы с ресурсом */
     createAgent(): ResourceAgentInstance<D>;
     /** Создает ссылку на ресурс с указанными аргументами */
-    createRef(args: D["Args"]): ResourceRefInstanse<D>;
+    createRef(args: D["Args"]): ResourceRefInstance<D>;
 };
 /**
  * Агент для работы с ресурсом
@@ -107,7 +107,7 @@ export type ResourceQueryState<D extends ResourceDefinition> = {
 export type ResourceTransaction = {
     patches: ImmerPatch[];
     inversePatches: ImmerPatch[];
-    status: 'pending' | 'committed' | 'aborted';
+    status: "pending" | "committed" | "aborted";
     abort(): void;
     commit(): void;
 };
@@ -115,13 +115,15 @@ export type ResourceTransaction = {
  * Эте не ссылка в "классическом" понимании, а абстракция
  * для работы с элементом кеша ресурса.
  */
-export type ResourceRefInstanse<D extends ResourceDefinition> = {
+export type ResourceRefInstance<D extends ResourceDefinition> = {
     get has(): boolean;
     lock(): {
         unlock: () => void;
     };
     unlockOne(): void;
-    patch(patchFn: (data: D['Data']) => void): ResourceTransaction | null;
+    patch(patchFn: (data: D["Data"]) => void): ResourceTransaction | null;
     invalidate(): void;
-    create(data: D['Data']): void;
+    create(data: D["Data"]): void;
 };
+/** @deprecated Use ResourceRefInstance. Will be removed in v0.6.0 */
+export type ResourceRefInstanse<D extends ResourceDefinition> = ResourceRefInstance<D>;

package/dist/query/types/index.d.ts

@@ -1,4 +1,4 @@
-export * from './Command.types';
-export * from './Resource.types';
-export * from './shared.types';
-export * from './Operation.types';
+export * from "./Command.types";
+export * from "./Resource.types";
+export * from "./shared.types";
+export * from "./Operation.types";

package/dist/query/types/index.js

@@ -1,5 +1,5 @@
-export * from './Command.types';
-export * from './Resource.types';
-export * from './shared.types';
+export * from "./Command.types";
+export * from "./Resource.types";
+export * from "./shared.types";
 // Deprecated Operation types (backward compatibility)
-export * from './Operation.types';
+export * from "./Operation.types";

package/dist/query-v2/api/createApi.d.ts

@@ -0,0 +1,10 @@
+import type { IApi, ICreateApiOptions } from "../../query-v2/types/api.types";
+import type { IPlugin } from "../../query-v2/types/plugin.types";
+/**
+ * Create a query-v2 API instance — the root entry point for managing resources, snapshots, and plugins.
+ *
+ * @param options - Configuration for the API instance (keyPrefix, plugins, snapshot, cache settings).
+ * @returns API instance with `createResource`, `resetAll`, and `getSnapshot` methods.
+ * @see docs/query-v2/README.md
+ */
+export declare function createApi<TPlugins extends IPlugin[] = []>(options?: ICreateApiOptions<TPlugins>): IApi<TPlugins>;

package/dist/query-v2/api/createApi.js

@@ -0,0 +1,83 @@
+import { ResourceV2 } from "../../query-v2/core/resource/ResourceV2";
+import { getSnapshot, hydrateSnapshot } from "../../query-v2/snapshot/Snapshot";
+const DEFAULT_CACHE_LIFETIME = 60_000;
+const DEFAULT_MAX_SNAPSHOT_DATA_AGE = 300_000; // 5 minutes
+/**
+ * Create a query-v2 API instance — the root entry point for managing resources, snapshots, and plugins.
+ *
+ * @param options - Configuration for the API instance (keyPrefix, plugins, snapshot, cache settings).
+ * @returns API instance with `createResource`, `resetAll`, and `getSnapshot` methods.
+ * @see docs/query-v2/README.md
+ */
+export function createApi(options = {}) {
+    const { keyPrefix = null, keyStrategy = "serialize", serializeArgs, compareArg, initialSnapshot = null, cacheLifetime = DEFAULT_CACHE_LIFETIME, plugins = [], maxSnapshotDataAge = DEFAULT_MAX_SNAPSHOT_DATA_AGE, doCacheArgs = false, } = options;
+    // ADR-6: Generic registry (Map, not typed to resources only)
+    const registry = new Map();
+    // Plugin initialization: call install() once per plugin
+    const pluginContext = {
+        get api() {
+            return api;
+        },
+        keyStrategy,
+    };
+    for (const plugin of plugins) {
+        plugin.install(pluginContext);
+    }
+    const api = {
+        createResource(resourceOptions) {
+            // Merge: resource options override API defaults
+            const mergedConfig = {
+                key: resourceOptions.key,
+                keyPrefix: keyPrefix ?? undefined,
+                keyStrategy,
+                queryFn: resourceOptions.queryFn,
+                onCacheEntryAdded: resourceOptions.onCacheEntryAdded,
+                onQueryStarted: resourceOptions.onQueryStarted,
+                serializeArgs: resourceOptions.serializeArgs ?? serializeArgs,
+                compareArg: resourceOptions.compareArg ?? compareArg,
+                cacheLifetime: resourceOptions.cacheLifetime ?? cacheLifetime,
+                beforeDevtoolsPush: resourceOptions.beforeDevtoolsPush,
+                maxSnapshotDataAge: resourceOptions.maxSnapshotDataAge ?? maxSnapshotDataAge,
+                doCacheArgs: resourceOptions.doCacheArgs ?? doCacheArgs,
+            };
+            // Validate unique key (for serialize strategy, key is expected for snapshot)
+            const resourceKey = mergedConfig.key;
+            if (resourceKey != null) {
+                if (registry.has(resourceKey)) {
+                    throw new Error(`Duplicate resource key "${resourceKey}". Each resource must have a unique key.`);
+                }
+            }
+            // Create resource
+            const resource = new ResourceV2(mergedConfig);
+            // Apply plugin augmentations
+            const augmentations = {};
+            for (const plugin of plugins) {
+                const pluginContributions = plugin.augmentResource(resource, resourceOptions);
+                Object.assign(augmentations, pluginContributions);
+            }
+            // Create the augmented resource
+            const augmentedResource = Object.assign(resource, augmentations);
+            // Register resource
+            if (resourceKey != null) {
+                registry.set(resourceKey, resource);
+            }
+            // Hydrate from initial snapshot if available
+            if (initialSnapshot && resourceKey != null) {
+                const snapshotMaxAge = mergedConfig.maxSnapshotDataAge ?? maxSnapshotDataAge;
+                const singleResourceRegistry = new Map();
+                singleResourceRegistry.set(resourceKey, resource);
+                hydrateSnapshot(initialSnapshot, singleResourceRegistry, keyPrefix, snapshotMaxAge);
+            }
+            return augmentedResource;
+        },
+        resetAll() {
+            for (const [, resource] of registry) {
+                resource.resetCache();
+            }
+        },
+        getSnapshot() {
+            return getSnapshot(registry, keyPrefix, keyStrategy);
+        },
+    };
+    return api;
+}

package/dist/query-v2/core/common/CacheEntry.d.ts

@@ -0,0 +1,29 @@
+import type { TBeforeDevtoolsPushFn } from "../../../query-v2/types/shared.types";
+import type { TMachineInstance } from "../machines/Machine";
+export interface CacheEntryOptions {
+    keyParts?: string[];
+    beforeDevtoolsPush?: TBeforeDevtoolsPushFn<unknown>;
+}
+/**
+ * Cache entry wrapping a reactive signal over a state machine instance.
+ * Represents a single cached query result with its full lifecycle (idle → pending → success/error).
+ */
+export declare class CacheEntry<TData = unknown, TError = Error> {
+    private readonly _signal;
+    private readonly _onClean$;
+    private _completed;
+    constructor(initialMachine: TMachineInstance<TData, TError>, options?: CacheEntryOptions);
+    /** Reactive accessor for the current machine state — reading this registers a signal dependency. */
+    get machine$(): () => TMachineInstance<TData, TError>;
+    /** Non-reactive read of the current machine state (does not register a signal dependency). */
+    peek(): TMachineInstance<TData, TError>;
+    /** Transition to a new machine state. No-op if the entry has been completed. */
+    set(machine: TMachineInstance<TData, TError>): void;
+    get onClean$(): {
+        subscribe: (cb: () => void) => {
+            unsubscribe: () => void;
+        };
+    };
+    /** Complete the entry — aborts pending patches, resets to idle, and notifies cleanup listeners. */
+    complete(): void;
+}

package/dist/query-v2/core/common/CacheEntry.js

@@ -0,0 +1,71 @@
+import { Subject } from "rxjs";
+import { Signal } from "../../../signals";
+import { MachineIdle } from "../machines/MachineIdle";
+import { MachineWithData } from "../machines/MachineWithData";
+/**
+ * Cache entry wrapping a reactive signal over a state machine instance.
+ * Represents a single cached query result with its full lifecycle (idle → pending → success/error).
+ */
+export class CacheEntry {
+    _signal;
+    _onClean$ = new Subject();
+    _completed = false;
+    constructor(initialMachine, options) {
+        const userCallback = options?.beforeDevtoolsPush;
+        // Default beforeDevtoolsPush projects machine → machine.state for devtools (ADR-8).
+        // The push function types are mismatched intentionally: we push plain state objects
+        // instead of machine instances to keep devtools output JSON-friendly.
+        const beforeDevtoolsPush = ((newValue, push) => {
+            const machine = newValue;
+            const state = machine.state;
+            if (userCallback) {
+                userCallback(state, push);
+            }
+            else {
+                push(state);
+            }
+        });
+        this._signal = Signal.state(initialMachine, {
+            key: options?.keyParts?.join("/"),
+            beforeDevtoolsPush,
+        });
+    }
+    /** Reactive accessor for the current machine state — reading this registers a signal dependency. */
+    get machine$() {
+        return this._signal;
+    }
+    /** Non-reactive read of the current machine state (does not register a signal dependency). */
+    peek() {
+        return this._signal.peek();
+    }
+    /** Transition to a new machine state. No-op if the entry has been completed. */
+    set(machine) {
+        if (this._completed)
+            return;
+        this._signal.set(machine);
+    }
+    get onClean$() {
+        return {
+            subscribe: (cb) => {
+                const sub = this._onClean$.subscribe(cb);
+                return { unsubscribe: () => sub.unsubscribe() };
+            },
+        };
+    }
+    /** Complete the entry — aborts pending patches, resets to idle, and notifies cleanup listeners. */
+    complete() {
+        if (this._completed)
+            return;
+        this._completed = true;
+        // Layer 3 (ADR-4): Abort all pending patches on MachineWithData instances
+        const current = this._signal.peek();
+        if (current instanceof MachineWithData) {
+            current.abortAllPendingPatches();
+        }
+        // Set to idle to release data references
+        this._signal.set(MachineIdle.create());
+        // Notify cleanup listeners
+        this._onClean$.next();
+        this._onClean$.complete();
+    }
+}

package/dist/query-v2/core/common/CacheMap.d.ts

@@ -0,0 +1,38 @@
+import type { ICacheMapOptions } from "../../../query-v2/types/cache.types";
+import type { CacheEntry } from "./CacheEntry";
+declare class SerializedCacheMap<TArgs, TData, TError = Error> {
+    private readonly _map;
+    private readonly _serializeArgs;
+    private readonly _argsMemo;
+    constructor(serializeArgs: (args: unknown) => string, doCacheArgs: boolean);
+    private _serialize;
+    get(args: TArgs): CacheEntry<TData, TError> | undefined;
+    set(args: TArgs, entry: CacheEntry<TData, TError>): void;
+    getOrCreate(args: TArgs, factory: () => CacheEntry<TData, TError>): CacheEntry<TData, TError>;
+    delete(args: TArgs): boolean;
+    has(args: TArgs): boolean;
+    values(): Iterable<CacheEntry<TData, TError>>;
+    entries(): Iterable<[string, CacheEntry<TData, TError>]>;
+    clear(): void;
+    get size(): number;
+}
+declare class CompareCacheMap<TArgs, TData, TError = Error> {
+    private readonly _items;
+    private readonly _compareArg;
+    constructor(compareArg: (a: unknown, b: unknown) => boolean);
+    private _findIndex;
+    get(args: TArgs): CacheEntry<TData, TError> | undefined;
+    set(args: TArgs, entry: CacheEntry<TData, TError>): void;
+    getOrCreate(args: TArgs, factory: () => CacheEntry<TData, TError>): CacheEntry<TData, TError>;
+    delete(args: TArgs): boolean;
+    has(args: TArgs): boolean;
+    values(): Iterable<CacheEntry<TData, TError>>;
+    entries(): Iterable<[TArgs, CacheEntry<TData, TError>]>;
+    clear(): void;
+    get size(): number;
+}
+export type TCacheMapInstance<TArgs, TData, TError = Error> = SerializedCacheMap<TArgs, TData, TError> | CompareCacheMap<TArgs, TData, TError>;
+export declare const CacheMap: {
+    create<TArgs, TData, TError = Error>(options: ICacheMapOptions<TArgs>): TCacheMapInstance<TArgs, TData, TError>;
+};
+export {};

package/dist/query-v2/core/common/CacheMap.js

@@ -0,0 +1,127 @@
+import { shallowEqual } from "../../../common/utils/shallowEqual";
+import { stableStringify } from "../../../query-v2/lib/stableStringify";
+class SerializedCacheMap {
+    _map = new Map();
+    _serializeArgs;
+    _argsMemo;
+    constructor(serializeArgs, doCacheArgs) {
+        this._serializeArgs = serializeArgs;
+        this._argsMemo = doCacheArgs ? new WeakMap() : null;
+    }
+    _serialize(args) {
+        if (this._argsMemo && typeof args === "object" && args !== null) {
+            let cached = this._argsMemo.get(args);
+            if (cached === undefined) {
+                cached = this._serializeArgs(args);
+                this._argsMemo.set(args, cached);
+            }
+            return cached;
+        }
+        return this._serializeArgs(args);
+    }
+    get(args) {
+        return this._map.get(this._serialize(args));
+    }
+    set(args, entry) {
+        this._map.set(this._serialize(args), entry);
+    }
+    getOrCreate(args, factory) {
+        const key = this._serialize(args);
+        let entry = this._map.get(key);
+        if (!entry) {
+            entry = factory();
+            this._map.set(key, entry);
+        }
+        return entry;
+    }
+    delete(args) {
+        return this._map.delete(this._serialize(args));
+    }
+    has(args) {
+        return this._map.has(this._serialize(args));
+    }
+    values() {
+        return this._map.values();
+    }
+    entries() {
+        return this._map.entries();
+    }
+    clear() {
+        this._map.clear();
+    }
+    get size() {
+        return this._map.size;
+    }
+}
+class CompareCacheMap {
+    _items = [];
+    _compareArg;
+    constructor(compareArg) {
+        this._compareArg = compareArg;
+    }
+    _findIndex(args) {
+        for (let i = 0; i < this._items.length; i++) {
+            if (this._compareArg(this._items[i].args, args)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    get(args) {
+        const idx = this._findIndex(args);
+        return idx >= 0 ? this._items[idx].entry : undefined;
+    }
+    set(args, entry) {
+        const idx = this._findIndex(args);
+        if (idx >= 0) {
+            this._items[idx] = { args, entry };
+        }
+        else {
+            this._items.push({ args, entry });
+        }
+    }
+    getOrCreate(args, factory) {
+        const idx = this._findIndex(args);
+        if (idx >= 0) {
+            return this._items[idx].entry;
+        }
+        const entry = factory();
+        this._items.push({ args, entry });
+        return entry;
+    }
+    delete(args) {
+        const idx = this._findIndex(args);
+        if (idx >= 0) {
+            this._items.splice(idx, 1);
+            return true;
+        }
+        return false;
+    }
+    has(args) {
+        return this._findIndex(args) >= 0;
+    }
+    *values() {
+        for (const item of this._items) {
+            yield item.entry;
+        }
+    }
+    *entries() {
+        for (const item of this._items) {
+            yield [item.args, item.entry];
+        }
+    }
+    clear() {
+        this._items.length = 0;
+    }
+    get size() {
+        return this._items.length;
+    }
+}
+export const CacheMap = {
+    create(options) {
+        if (options.keyStrategy === "compare") {
+            return new CompareCacheMap(options.compareArg ?? shallowEqual);
+        }
+        return new SerializedCacheMap(options.serializeArgs ?? stableStringify, options.doCacheArgs);
+    },
+};

package/dist/query-v2/core/common/LifecycleHooks.d.ts

@@ -0,0 +1,22 @@
+import type { TOnCacheEntryAdded, TOnQueryStarted } from "../../../query-v2/types/lifecycle.types";
+import type { TMachineInstance } from "../machines/Machine";
+import type { CacheEntry } from "./CacheEntry";
+export declare class LifecycleHooks<TArgs, TData, TError = Error> {
+    private readonly _onCacheEntryAdded?;
+    private readonly _onQueryStarted?;
+    private _cacheEntryState;
+    private _queryState;
+    private _serializeArgs;
+    constructor(options: {
+        onCacheEntryAdded?: TOnCacheEntryAdded<TArgs, TData>;
+        onQueryStarted?: TOnQueryStarted<TArgs, TData>;
+        serializeArgs: (args: unknown) => string;
+    });
+    fireCacheEntryAdded(args: TArgs, getCacheEntry: () => TMachineInstance<TData, TError>): void;
+    fireCacheEntryRemoved(args: TArgs): void;
+    resolveCacheDataLoaded(args: TArgs, data: TData): void;
+    fireQueryStarted(args: TArgs, getCacheEntry: () => CacheEntry<TData, TError>): void;
+    resolveQueryFulfilled(data: TData): void;
+    rejectQueryFulfilled(error: unknown): void;
+    clearAll(): void;
+}