@fozy-labs/rx-toolkit 0.5.3 → 0.6.0

package/dist/query/core/syncer/Syncer.d.ts

@@ -0,0 +1,32 @@
+import type { ISyncDriver, TResourceOptions } from "../../../query/types";
+import type { Resource } from "../resource/Resource";
+export interface ISyncerConfig {
+    syncDriver: ISyncDriver;
+    keyPrefix: string | null;
+    defaultSync: "none" | "resources" | "all";
+    resourcesByKey: Map<string, Resource<any, any>>;
+}
+/**
+ * Encapsulates cross-tab sync (REQ/RES) logic previously inlined in createApi.
+ */
+export declare class Syncer {
+    private static readonly SYNC_TIMEOUT_MS;
+    private readonly pendingRequests;
+    private readonly syncDriver;
+    private readonly keyPrefix;
+    private readonly defaultSync;
+    private readonly resourcesByKey;
+    constructor(config: ISyncerConfig);
+    /** Connect the sync driver and start listening for messages. */
+    connect(): void;
+    /** Create a beforeQuery hook for resource config. */
+    get beforeQuery(): (resourceKey: string, entryKey: string) => Promise<{
+        data: unknown;
+    } | null>;
+    /** Check whether sync is enabled for a given resource options. */
+    isResourceSyncEnabled(opts: TResourceOptions<any, any>): boolean;
+    /** Clear pending requests and reconnect the sync driver (used by resetAll). */
+    cleanup(): void;
+    private handleIncomingSyncMessage;
+    private requestDataFromOtherTabs;
+}

package/dist/query/core/syncer/Syncer.js

@@ -0,0 +1,85 @@
+/**
+ * Encapsulates cross-tab sync (REQ/RES) logic previously inlined in createApi.
+ */
+export class Syncer {
+    static SYNC_TIMEOUT_MS = 150;
+    pendingRequests = new Map();
+    syncDriver;
+    keyPrefix;
+    defaultSync;
+    resourcesByKey;
+    constructor(config) {
+        this.syncDriver = config.syncDriver;
+        this.keyPrefix = config.keyPrefix;
+        this.defaultSync = config.defaultSync;
+        this.resourcesByKey = config.resourcesByKey;
+    }
+    /** Connect the sync driver and start listening for messages. */
+    connect() {
+        this.syncDriver.connect(this.handleIncomingSyncMessage);
+    }
+    /** Create a beforeQuery hook for resource config. */
+    get beforeQuery() {
+        return (resourceKey, entryKey) => this.requestDataFromOtherTabs(resourceKey, entryKey);
+    }
+    /** Check whether sync is enabled for a given resource options. */
+    isResourceSyncEnabled(opts) {
+        if (opts.sync !== undefined)
+            return opts.sync;
+        return this.defaultSync === "resources" || this.defaultSync === "all";
+    }
+    /** Clear pending requests and reconnect the sync driver (used by resetAll). */
+    cleanup() {
+        for (const [, pending] of this.pendingRequests) {
+            clearTimeout(pending.timer);
+            pending.resolve(null);
+        }
+        this.pendingRequests.clear();
+        this.syncDriver.disconnect();
+        this.syncDriver.connect(this.handleIncomingSyncMessage);
+    }
+    // ── Private ──
+    handleIncomingSyncMessage = (msg) => {
+        if (msg.type === "REQ") {
+            if (msg.keys[0] !== (this.keyPrefix ?? ""))
+                return;
+            const resource = this.resourcesByKey.get(msg.keys[1]);
+            if (!resource)
+                return;
+            const entryKey = msg.keys[2];
+            const entry = resource.getEntry(entryKey);
+            if (!entry)
+                return;
+            const machine = entry.peek();
+            if (machine.state.status === "success") {
+                const data = machine.state.patchState ? machine.state.patchState.originalData : machine.state.data;
+                this.syncDriver.send({
+                    type: "RES",
+                    reqId: msg.reqId,
+                    keys: msg.keys,
+                    data,
+                });
+            }
+        }
+        else if (msg.type === "RES") {
+            const pending = this.pendingRequests.get(msg.reqId);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.pendingRequests.delete(msg.reqId);
+                pending.resolve(msg.data !== undefined ? { data: msg.data } : null);
+            }
+        }
+    };
+    requestDataFromOtherTabs(resourceKey, entryKey) {
+        const reqId = crypto.randomUUID();
+        const keys = [this.keyPrefix ?? "", resourceKey, entryKey];
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(reqId);
+                resolve(null);
+            }, Syncer.SYNC_TIMEOUT_MS);
+            this.pendingRequests.set(reqId, { resolve, timer });
+            this.syncDriver.send({ type: "REQ", reqId, keys });
+        });
+    }
+}

package/dist/query/core/syncer/index.d.ts

@@ -0,0 +1,2 @@
+export { Syncer } from "./Syncer";
+export type { ISyncerConfig } from "./Syncer";

package/dist/query/core/syncer/index.js

@@ -0,0 +1 @@
+export { Syncer } from "./Syncer";

package/dist/query/index.d.ts

@@ -1,11 +1,6 @@
-export * from "./api/createCommand";
-export * from "./react/useCommandAgent";
-export * from "./api/createResource";
-export * from "./api/createResourceDuplicator";
-export * from "./api/resetAllQueriesCache";
-export * from "./SKIP_TOKEN";
+export * from "./api";
+export * from "./constants";
+export * from "./lib";
+export * from "./react";
 export * from "./types";
-export * from "./react/useResourceAgent";
-export * from "./react/useResourceRef";
-export * from "./api/createOperation";
-export * from "./react/useOperationAgent";
+export { Machine, MachineBase, MachineWithData, MachinePending, MachineSuccess, MachineError, MachineRefreshing, MachineRefreshError, } from "./core/machine";

package/dist/query/index.js

@@ -1,14 +1,6 @@
-// Command API
-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 "./api";
+export * from "./constants";
+export * from "./lib";
+export * from "./react";
 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 { Machine, MachineBase, MachineWithData, MachinePending, MachineSuccess, MachineError, MachineRefreshing, MachineRefreshError, } from "./core/machine";

package/dist/query/lib/broadcastSyncDriver.d.ts

@@ -0,0 +1,5 @@
+import type { ISyncDriver } from "../types";
+export interface BroadcastSyncDriverOptions {
+    channel?: string;
+}
+export declare function broadcastSyncDriver(options?: BroadcastSyncDriverOptions): ISyncDriver;

package/dist/query/lib/broadcastSyncDriver.js

@@ -0,0 +1,46 @@
+function isValidSyncMessage(msg) {
+    if (msg == null || typeof msg !== "object")
+        return false;
+    const m = msg;
+    return ((m.type === "REQ" || m.type === "RES") &&
+        typeof m.reqId === "string" &&
+        Array.isArray(m.keys) &&
+        m.keys.length === 3 &&
+        m.keys.every((k) => typeof k === "string"));
+}
+export function broadcastSyncDriver(options) {
+    const channelName = options?.channel ?? "rx-toolkit";
+    let bc = null;
+    return {
+        connect(onMessage) {
+            try {
+                bc = new BroadcastChannel(channelName);
+                bc.onmessage = (ev) => {
+                    if (isValidSyncMessage(ev.data)) {
+                        onMessage(ev.data);
+                    }
+                };
+            }
+            catch {
+                bc = null;
+            }
+        },
+        disconnect() {
+            try {
+                bc?.close();
+            }
+            catch {
+                /* noop */
+            }
+            bc = null;
+        },
+        send(message) {
+            try {
+                bc?.postMessage(message);
+            }
+            catch {
+                /* noop — channel may be closed or unavailable */
+            }
+        },
+    };
+}

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

@@ -0,0 +1,3 @@
+export * from "./broadcastSyncDriver";
+export * from "./stableStringify";
+export * from "./toKeyed";

package/dist/query/lib/index.js

@@ -0,0 +1,3 @@
+export * from "./broadcastSyncDriver";
+export * from "./stableStringify";
+export * from "./toKeyed";

package/dist/{query-v2 → query}/lib/stableStringify.js

@@ -1,6 +1,3 @@
-function isPlainObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
 /**
  * Deterministic JSON.stringify with sorted object keys.
  * Used as the default serializeArgs for the 'serialize' key strategy.
@@ -9,6 +6,8 @@ function isPlainObject(value) {
  * Does NOT handle: Date, Map, Set, RegExp (documented limitation).
  */
 export function stableStringify(value) {
+    if (value === undefined)
+        return "undefined";
     return JSON.stringify(value, (_, val) => {
         if (isPlainObject(val)) {
             return Object.keys(val)
@@ -21,3 +20,6 @@ export function stableStringify(value) {
         return val;
     });
 }
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/query/lib/toKeyed.d.ts

@@ -0,0 +1,11 @@
+import type { Args, Keyed } from "../types";
+/**
+ * Type guard: returns `true` if `args` is already wrapped in `Keyed<T>`.
+ */
+export declare function isKeyed<T>(args: Args<T>): args is Keyed<T>;
+/**
+ * Normalizes raw args into `Keyed<T>`.
+ * If `args` is already `Keyed`, it passes through unchanged.
+ * Otherwise wraps with `{ value: args, key: serializeFn(args) }`.
+ */
+export declare function toKeyed<T>(args: Args<T>, serializeFn?: (value: T) => string): Keyed<T>;

package/dist/query/lib/toKeyed.js

@@ -0,0 +1,18 @@
+import { KEYED_BRAND } from "../constants";
+import { stableStringify } from "./stableStringify";
+/**
+ * Type guard: returns `true` if `args` is already wrapped in `Keyed<T>`.
+ */
+export function isKeyed(args) {
+    return args !== null && typeof args === "object" && KEYED_BRAND in args;
+}
+/**
+ * Normalizes raw args into `Keyed<T>`.
+ * If `args` is already `Keyed`, it passes through unchanged.
+ * Otherwise wraps with `{ value: args, key: serializeFn(args) }`.
+ */
+export function toKeyed(args, serializeFn = stableStringify) {
+    if (isKeyed(args))
+        return args;
+    return { value: args, key: serializeFn(args), [KEYED_BRAND]: true };
+}

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

@@ -0,0 +1,31 @@
+import type { ArgsOrVoidOrSkip, ICommand, IPlugin, IPluginContext, IResource, PluginHKT, TCommandAgentState, TCommandOptions, TResourceAgentState, TResourceOptions } from "../../query/types";
+/** Resource augmentation shape produced by ReactHooksPlugin. */
+type ReactHooksResourceShape<TArgs, TData> = {
+    useResource: (args: ArgsOrVoidOrSkip<TArgs>) => TResourceAgentState<TArgs, TData>;
+};
+/** Command augmentation shape produced by ReactHooksPlugin. */
+type ReactHooksCommandShape<TArgs, TData> = {
+    useCommand: (key?: string) => [trigger: (args: TArgs) => Promise<TData>, state: TCommandAgentState<TArgs, TData>];
+};
+/**
+ * HKT declaration for ReactHooksPlugin.
+ * Uses `this['_TArgs']` and `this['_TData']` which become concrete when
+ * applied through `ApplyPluginResourceHKT` / `ApplyPluginCommandHKT`.
+ */
+export interface ReactHooksPluginHKT extends PluginHKT {
+    readonly resourceType: ReactHooksResourceShape<this["_TArgs"], this["_TData"]>;
+    readonly commandType: ReactHooksCommandShape<this["_TArgs"], this["_TData"]>;
+}
+export declare class ReactHooksPlugin implements IPlugin {
+    readonly name = "ReactHooksPlugin";
+    readonly _hkt: ReactHooksPluginHKT;
+    install(_context: IPluginContext): void;
+    augmentResource<TArgs, TData>(resource: IResource<TArgs, TData>, _options: TResourceOptions<TArgs, TData>): {
+        useResource: (args: ArgsOrVoidOrSkip<TArgs>) => TResourceAgentState<TArgs, TData>;
+    };
+    augmentCommand<TArgs, TData>(command: ICommand<TArgs, TData>, _options: TCommandOptions<TArgs, TData>): {
+        useCommand: (key?: string) => [trigger: (args: TArgs) => Promise<TData>, state: TCommandAgentState<TArgs, TData>];
+    };
+}
+export declare function reactHooksPlugin(): ReactHooksPlugin;
+export {};

package/dist/query/react/ReactHooksPlugin.js

@@ -0,0 +1,21 @@
+import { useCommand } from "./useCommand";
+import { useResource } from "./useResource";
+export class ReactHooksPlugin {
+    name = "ReactHooksPlugin";
+    install(_context) {
+        // no-op
+    }
+    augmentResource(resource, _options) {
+        return {
+            useResource: (args) => useResource(resource, args),
+        };
+    }
+    augmentCommand(command, _options) {
+        return {
+            useCommand: (key) => useCommand(command, key),
+        };
+    }
+}
+export function reactHooksPlugin() {
+    return new ReactHooksPlugin();
+}

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

@@ -0,0 +1,3 @@
+export * from "./useResource";
+export * from "./useCommand";
+export * from "./ReactHooksPlugin";

package/dist/query/react/index.js

@@ -0,0 +1,3 @@
+export * from "./useResource";
+export * from "./useCommand";
+export * from "./ReactHooksPlugin";

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

@@ -0,0 +1,2 @@
+import type { ICommand, TCommandAgentState } from "../../query/types";
+export declare function useCommand<TArgs, TData>(command: ICommand<TArgs, TData>, key?: string): [trigger: (args: TArgs) => Promise<TData>, state: TCommandAgentState<TArgs, TData>];

package/dist/query/react/useCommand.js

@@ -0,0 +1,14 @@
+import React from "react";
+import { useConstant, useEventHandler } from "../../common/react";
+import { useSignal } from "../../signals/react";
+export function useCommand(command, key) {
+    const agent = useConstant(() => command.createAgent(key), [command]);
+    React.useEffect(() => {
+        if (key !== undefined) {
+            agent.setKey(key);
+        }
+    }, [agent, key]);
+    const state = useSignal(agent.state$);
+    const trigger = useEventHandler((args) => agent.trigger(args));
+    return [trigger, state];
+}

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

@@ -0,0 +1,2 @@
+import type { ArgsOrVoidOrSkip, IResource, TResourceAgentState } from "../../query/types";
+export declare function useResource<TArgs, TData>(resource: IResource<TArgs, TData>, args: ArgsOrVoidOrSkip<TArgs>): TResourceAgentState<TArgs, TData>;

package/dist/query/react/useResource.js

@@ -0,0 +1,16 @@
+import { useConstant, useIsomorphicLayoutEffect } from "../../common/react";
+import { useSignal } from "../../signals/react";
+export function useResource(resource, args) {
+    const agent = useConstant(() => {
+        const r = resource.createAgent();
+        r.set(args, true);
+        return r;
+    }, [resource]);
+    if (agent.args !== args) {
+        agent.set(args, true);
+    }
+    useIsomorphicLayoutEffect(() => {
+        agent.start();
+    }, [agent]);
+    return useSignal(agent.state$);
+}

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

@@ -0,0 +1,39 @@
+import type { TCacheEntryAddedContext, TQueryStartedContext } from "./cache";
+import type { ICommand, TCommandOptions } from "./command";
+import type { CombinePluginCommandAugments, CombinePluginResourceAugments, PluginHKT } from "./plugin-hkt";
+import type { IResource, TResourceOptions } from "./resource";
+import type { ISyncDriver, TApiSnapshot } from "./snapshot";
+export interface IPluginContext {
+    keyPrefix: string;
+}
+export interface IPlugin {
+    readonly name: string;
+    install(context: IPluginContext): void;
+    augmentResource?<TArgs, TData>(resource: IResource<TArgs, TData>, options: TResourceOptions<TArgs, TData>): Record<string, unknown>;
+    augmentCommand?<TArgs, TData>(command: ICommand<TArgs, TData>, options: TCommandOptions<TArgs, TData>): Record<string, unknown>;
+    /**
+     * Phantom type member. Plugins that provide typed augmentations should
+     * `declare readonly _hkt: MyPluginHKT` where `MyPluginHKT extends PluginHKT`.
+     * Never set at runtime — purely a compile-time protocol.
+     */
+    readonly _hkt?: PluginHKT;
+}
+export interface TCreateApiOptions<TPlugins extends readonly IPlugin[] = readonly IPlugin[]> {
+    keyPrefix?: string | null;
+    plugins?: TPlugins;
+    serializeArgs?: (args: unknown) => string;
+    resourceRetentionTime?: number | false;
+    commandRetentionTime?: number | false;
+    initialSnapshot?: TApiSnapshot | null;
+    snapshotValidTime?: number | false;
+    defaultSync?: "none" | "resources" | "all";
+    syncDriver?: ISyncDriver;
+    onCacheEntryAdded?: (args: unknown, ctx: TCacheEntryAddedContext<unknown, unknown>) => void;
+    onQueryStarted?: (args: unknown, ctx: TQueryStartedContext<unknown, unknown>) => void | Promise<void>;
+}
+export interface IApi<TPlugins extends readonly IPlugin[] = readonly IPlugin[]> {
+    createResource<TArgs = void, TData = unknown>(options: TResourceOptions<TArgs, TData>): IResource<TArgs, TData> & CombinePluginResourceAugments<TPlugins, TArgs, TData>;
+    createCommand<TArgs = void, TData = unknown>(options: TCommandOptions<TArgs, TData>): ICommand<TArgs, TData> & CombinePluginCommandAugments<TPlugins, TArgs, TData>;
+    getSnapshot(): TApiSnapshot;
+    resetAll(): void;
+}

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

@@ -0,0 +1,51 @@
+import { Subject } from "rxjs";
+import type { Machine } from "../../query/core/machine";
+import type { ReadableSignalFnLike } from "../../signals/types";
+import type { IPatchHandle, Keyed } from "./common";
+export interface ICacheEntryOptions<TState> {
+    retentionTime: number | false;
+    devtoolsKey: string;
+    beforeDevtoolsPush?: (state: TState) => TState;
+}
+export interface ICacheEntry<TState> {
+    readonly completed$: Subject<void>;
+    readonly state$: ReadableSignalFnLike<TState>;
+    peek(): TState;
+    set(state: TState): void;
+    complete(): void;
+}
+export interface ICacheMap<TValue> {
+    readonly size: number;
+    get(key: string): TValue | undefined;
+    set(key: string, value: TValue): void;
+    delete(key: string): boolean;
+    has(key: string): boolean;
+    clear(): void;
+    values(): IterableIterator<TValue>;
+}
+export interface IQueryCacheEntryOptions<TArgs, TData> {
+    queryFn: (keyedArgs: Keyed<TArgs>, signal: AbortSignal) => Promise<TData>;
+    retentionTime: number | false;
+    keyedArgs: Keyed<TArgs>;
+    resourceKey?: string;
+    initialMachine?: Machine<TArgs, TData>;
+    beforeDevtoolsPush?: (machine: Machine<TArgs, TData>) => any;
+}
+export interface IQueryCacheEntry<TArgs, TData> extends ICacheEntry<Machine<TArgs, TData>> {
+    readonly keyedArgs: Keyed<TArgs>;
+    readonly machine$: ReadableSignalFnLike<Machine<TArgs, TData>>;
+    refresh(): void;
+    retry(): void;
+    createPatch(patchFn: (data: TData) => void): IPatchHandle | null;
+}
+export interface TCacheEntryAddedContext<TArgs, TData> {
+    entry: IQueryCacheEntry<TArgs, TData>;
+    $cacheDataLoaded: Promise<TData>;
+    $cacheEntryRemoved: Promise<void>;
+}
+export interface TQueryStartedContext<TArgs, TData> {
+    entry: IQueryCacheEntry<TArgs, TData>;
+    $queryFulfilled: Promise<{
+        data: TData;
+    }>;
+}

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

@@ -0,0 +1,52 @@
+import type { ReadableSignalFnLike } from "../../signals/types";
+import type { IQueryCacheEntry, TCacheEntryAddedContext, TQueryStartedContext } from "./cache";
+import type { Args } from "./common";
+import type { IResource } from "./resource";
+import type { TCommandAgentState } from "./state";
+export interface TLinkConfig<TArgs, TData, TResArgs, TResData> {
+    resource: IResource<TResArgs, TResData>;
+    forwardArgs: (commandArgs: TArgs) => TResArgs | undefined;
+    invalidate?: boolean;
+    optimisticUpdate?: (draft: TResData, commandArgs: TArgs) => void;
+    update?: (draft: TResData, commandArgs: TArgs, result: TData) => void;
+}
+export type TLinksInput<TArgs, TData> = TLinkConfig<TArgs, TData, any, any>[] | ((link: (config: TLinkConfig<TArgs, TData, any, any>) => void) => void);
+export interface ICommand<TArgs, TData> {
+    trigger(args: Args<TArgs>, key?: string): Promise<TData>;
+    getEntry(key: string): IQueryCacheEntry<TArgs, TData> | null;
+    getEntry$(key: string): IQueryCacheEntry<TArgs, TData> | null;
+    createAgent(key?: string): ICommandAgent<TArgs, TData>;
+}
+export interface ICommandAgent<TArgs, TData> {
+    state$: ReadableSignalFnLike<TCommandAgentState<TArgs, TData>>;
+    trigger(args: Args<TArgs>, key?: string): Promise<TData>;
+    setKey(key: string): void;
+}
+export interface TCommandOptions<TArgs, TData> {
+    queryFn: (args: TArgs) => Promise<TData>;
+    key?: string;
+    links?: TLinksInput<TArgs, TData>;
+    retentionTime?: number | false;
+    onCacheEntryAdded?: (args: TArgs, ctx: TCacheEntryAddedContext<TArgs, TData>) => void;
+    onQueryStarted?: (args: TArgs, ctx: TQueryStartedContext<TArgs, TData>) => void | Promise<void>;
+}
+/**
+ * Configuration object for creating a {@link Command}.
+ *
+ * @template TArgs - The argument type accepted by the mutation function.
+ * @template TData - The data type returned by the mutation function.
+ */
+export interface ICommandConfig<TArgs, TData> {
+    /** Function that executes the mutation. */
+    queryFn: (args: TArgs) => Promise<TData>;
+    /** Optional prefix for cache keys and devtools display. */
+    key?: string;
+    /** Link descriptors that bind this command to related resources. */
+    links: TLinkConfig<TArgs, TData, any, any>[];
+    /** Time (ms) to keep a cache entry after subscribers drop off. `false` disables auto-removal. */
+    retentionTime: number | false;
+    /** Called when a new cache entry is created. See lifecycle hooks documentation. */
+    onCacheEntryAdded?: (args: TArgs, ctx: TCacheEntryAddedContext<TArgs, TData>) => void;
+    /** Called every time `queryFn` starts. See lifecycle hooks documentation. */
+    onQueryStarted?: (args: TArgs, ctx: TQueryStartedContext<TArgs, TData>) => void | Promise<void>;
+}

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

@@ -0,0 +1,65 @@
+import type { Patch } from "immer";
+import type { KEYED_BRAND, SKIP } from "../constants";
+export type Keyed<T> = {
+    value: T;
+    key: string;
+    readonly [KEYED_BRAND]: true;
+};
+export type Args<TArgs> = TArgs | Keyed<TArgs>;
+export type ArgsOrVoid<TArgs> = TArgs extends void ? void : Args<TArgs>;
+export type ArgsOrVoidOrSkip<TArgs> = TArgs extends void ? void | typeof SKIP : Args<TArgs> | typeof SKIP;
+export type TMachineStatus = "pending" | "success" | "error" | "refreshing" | "refresh-error";
+export interface TPendingState<TArgs> {
+    status: "pending";
+    args: TArgs;
+    data: null;
+    error: null;
+    updatedAt: null;
+}
+export interface TSuccessState<TArgs, TData> {
+    status: "success";
+    args: TArgs;
+    data: TData;
+    error: null;
+    updatedAt: number;
+    patchState: TPatchState<TData> | null;
+}
+export interface TErrorState<TArgs> {
+    status: "error";
+    args: TArgs;
+    data: null;
+    error: unknown;
+    updatedAt: null;
+}
+export interface TRefreshingState<TArgs, TData> {
+    status: "refreshing";
+    args: TArgs;
+    data: TData;
+    error: null;
+    updatedAt: number;
+    patchState: TPatchState<TData> | null;
+}
+export interface TRefreshErrorState<TArgs, TData> {
+    status: "refresh-error";
+    args: TArgs;
+    data: TData;
+    error: unknown;
+    updatedAt: number;
+    patchState: TPatchState<TData> | null;
+}
+export type TMachineState<TArgs, TData> = TPendingState<TArgs> | TSuccessState<TArgs, TData> | TErrorState<TArgs> | TRefreshingState<TArgs, TData> | TRefreshErrorState<TArgs, TData>;
+export interface TPatchEntry {
+    forward: Patch[];
+    inverse: Patch[];
+    status: "pending" | "committed" | "aborted";
+}
+export interface TPatchState<TData> {
+    originalData: TData;
+    patches: TPatchEntry[];
+    isConsistencyViolation: boolean;
+}
+export interface IPatchHandle {
+    commit(): void;
+    abort(): void;
+}
+export type TAgentStatus = TMachineStatus | "idle";

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

@@ -1,4 +1,8 @@
-export * from "./Command.types";
-export * from "./Resource.types";
-export * from "./shared.types";
-export * from "./Operation.types";
+export * from "./common";
+export * from "./cache";
+export * from "./state";
+export * from "./snapshot";
+export * from "./resource";
+export * from "./command";
+export * from "./api";
+export * from "./plugin-hkt";

package/dist/query/types/index.js

@@ -1,5 +1,8 @@
-export * from "./Command.types";
-export * from "./Resource.types";
-export * from "./shared.types";
-// Deprecated Operation types (backward compatibility)
-export * from "./Operation.types";
+export * from "./common";
+export * from "./cache";
+export * from "./state";
+export * from "./snapshot";
+export * from "./resource";
+export * from "./command";
+export * from "./api";
+export * from "./plugin-hkt";