@fozy-labs/rx-toolkit 0.5.4 → 0.6.2

package/dist/query-v2/core/machines/Patcher.js

@@ -1,104 +0,0 @@
-import { applyPatches, enablePatches, produceWithPatches } from "immer";
-import { NO_VALUE } from "../../../query-v2/lib/NO_VALUE";
-enablePatches();
-function applyImmerPatches(data, patches) {
-    return applyPatches(data, patches);
-}
-export class Patcher {
-    static createPatch(patchFn, data) {
-        const [, patches, inversePatches] = produceWithPatches(data, patchFn);
-        return {
-            patches,
-            inversePatches,
-            status: "pending",
-        };
-    }
-    static resolvePatches(originalData, patches) {
-        let currentData = originalData;
-        let baseData = originalData;
-        const remainingPatches = [];
-        let foundPending = false;
-        const lastPendingIndex = patches.findLastIndex((p) => p.status === "pending");
-        patches.forEach((patch, index) => {
-            if (patch.status === "pending") {
-                foundPending = true;
-                currentData = applyImmerPatches(currentData, patch.patches);
-                remainingPatches.push(patch);
-            }
-            else if (foundPending) {
-                if (patch.status === "committed") {
-                    currentData = applyImmerPatches(currentData, patch.patches);
-                    remainingPatches.push(patch);
-                }
-                else if (patch.status === "aborted") {
-                    const hasPendingAfter = index < lastPendingIndex;
-                    if (hasPendingAfter) {
-                        currentData = applyImmerPatches(currentData, patch.inversePatches);
-                        remainingPatches.push(patch);
-                    }
-                    // No pending after → remove from queue
-                }
-            }
-            else {
-                // Before first pending
-                if (patch.status === "committed") {
-                    currentData = applyImmerPatches(currentData, patch.patches);
-                    baseData = currentData;
-                    // committed before pending → remove from queue
-                }
-                else if (patch.status === "aborted") {
-                    // aborted before pending → remove from queue
-                }
-            }
-        });
-        return { data: currentData, patches: remainingPatches, baseData };
-    }
-    static finishPatch(originalData, patches, type, patch) {
-        if (!patches) {
-            return { originalData, patches: null, data: null };
-        }
-        // Mark the target patch
-        patch.status = type === "commit" ? "committed" : "aborted";
-        // If no originalData, nothing to resolve
-        if (originalData === NO_VALUE) {
-            return { originalData, patches, data: null };
-        }
-        // Resolve patches
-        const resolved = Patcher.resolvePatches(originalData, patches);
-        const hasPending = resolved.patches.some((p) => p.status === "pending");
-        if (!hasPending) {
-            // No pending patches remain → clear originalData and patches
-            return {
-                originalData: NO_VALUE,
-                patches: resolved.patches.length > 0 ? resolved.patches : null,
-                data: resolved.data,
-            };
-        }
-        return {
-            originalData: resolved.baseData,
-            patches: resolved.patches.length > 0 ? resolved.patches : null,
-            data: resolved.data,
-        };
-    }
-    static abortAllPending(originalData, patches) {
-        if (!patches) {
-            return { originalData, patches: null, data: null };
-        }
-        // Mark all pending as aborted
-        for (const patch of patches) {
-            if (patch.status === "pending") {
-                patch.status = "aborted";
-            }
-        }
-        if (originalData === NO_VALUE) {
-            return { originalData: NO_VALUE, patches: null, data: null };
-        }
-        // Resolve: all should be either committed or aborted now
-        const resolved = Patcher.resolvePatches(originalData, patches);
-        return {
-            originalData: NO_VALUE,
-            patches: null,
-            data: resolved.data,
-        };
-    }
-}

package/dist/query-v2/core/machines/index.d.ts

@@ -1,8 +0,0 @@
-export { Machine, type TMachineInstance } from "./Machine";
-export { MachineIdle } from "./MachineIdle";
-export { MachinePending } from "./MachinePending";
-export { MachineSuccess } from "./MachineSuccess";
-export { MachineError } from "./MachineError";
-export { MachineRefreshing } from "./MachineRefreshing";
-export { MachineWithData } from "./MachineWithData";
-export { Patcher } from "./Patcher";

package/dist/query-v2/core/machines/index.js

@@ -1,8 +0,0 @@
-export { Machine } from "./Machine";
-export { MachineIdle } from "./MachineIdle";
-export { MachinePending } from "./MachinePending";
-export { MachineSuccess } from "./MachineSuccess";
-export { MachineError } from "./MachineError";
-export { MachineRefreshing } from "./MachineRefreshing";
-export { MachineWithData } from "./MachineWithData";
-export { Patcher } from "./Patcher";

package/dist/query-v2/core/resource/ResourceV2.d.ts

@@ -1,120 +0,0 @@
-import type { IResourceV2Agent } from "../../../query-v2/types/agent.types";
-import type { ICacheEntry } from "../../../query-v2/types/cache.types";
-import type { TOnCacheEntryAdded, TOnQueryStarted } from "../../../query-v2/types/lifecycle.types";
-import type { TMachine, TPatchFn } from "../../../query-v2/types/machine.types";
-import type { IResourceV2 } from "../../../query-v2/types/resource.types";
-import type { TBeforeDevtoolsPushFn, TCompareArgsFn, TQueryFn, TSerializeArgsFn } from "../../../query-v2/types/shared.types";
-import { CacheEntry } from "../common/CacheEntry";
-import type { TMachineInstance } from "../machines/Machine";
-export interface ResourceV2Config<TArgs, TData, TError = Error> {
-    key?: string;
-    keyPrefix?: string;
-    keyStrategy?: "serialize" | "compare";
-    queryFn: TQueryFn<TArgs, TData>;
-    onCacheEntryAdded?: TOnCacheEntryAdded<TArgs, TData>;
-    onQueryStarted?: TOnQueryStarted<TArgs, TData>;
-    serializeArgs?: TSerializeArgsFn;
-    compareArg?: TCompareArgsFn;
-    cacheLifetime?: number;
-    beforeDevtoolsPush?: TBeforeDevtoolsPushFn<TMachine<TData, TError>>;
-    maxSnapshotDataAge?: number;
-    doCacheArgs?: boolean;
-}
-/**
- * Cache-backed resource manager.
- * Orchestrates queries, caching, lifecycle hooks, GC, and optimistic patches for a single resource type.
- */
-export declare class ResourceV2<TArgs, TData, TError = Error> implements IResourceV2<TArgs, TData, TError> {
-    private readonly _cache;
-    private readonly _queryFn;
-    private readonly _lifecycleHooks;
-    private readonly _serializeArgs;
-    private readonly _compareArg;
-    private readonly _keyStrategy;
-    private readonly _cacheLifetime;
-    private readonly _beforeDevtoolsPush?;
-    private readonly _key?;
-    private readonly _keyPrefix?;
-    /** In-flight queries keyed by serialized args — for dedup + abort */
-    private readonly _inFlight;
-    /** Cache lifetime timers keyed by serialized args */
-    private readonly _gcTimers;
-    /** Refresh error listeners (used by Agent for refreshError tracking) */
-    private readonly _refreshErrorListeners;
-    constructor(config: ResourceV2Config<TArgs, TData, TError>);
-    /**
-     * Create an agent that tracks a single cache entry with reactive state (SWR).
-     *
-     * @returns A new agent bound to this resource.
-     */
-    createAgent(): IResourceV2Agent<TArgs, TData, TError>;
-    /**
-     * Execute a query for the given args, returning the cache entry.
-     * Deduplicates concurrent calls for the same args unless `doForce` is set.
-     *
-     * @param args - Query arguments (used as cache key).
-     * @param doForce - If true, bypass dedup and re-execute the query.
-     * @returns The cache entry after query initiation.
-     */
-    query(args: TArgs, doForce?: boolean): Promise<ICacheEntry<TData, TError>>;
-    /**
-     * Reactive query — read machine state as a signal dependency.
-     * Initiates the query if not already cached.
-     *
-     * @param args - Query arguments.
-     * @returns Current machine state (registers a reactive subscription).
-     */
-    query$(args: TArgs, doForce?: boolean): TMachine<TData, TError>;
-    /**
-     * Get the cache entry for the given args without initiating a query (unless `doInitiate` is set).
-     *
-     * @param args - Query arguments.
-     * @returns The cache entry, or `null` if not cached.
-     */
-    entry(args: TArgs, doInitiate?: boolean): ICacheEntry<TData, TError> | null;
-    entry$(args: TArgs, doInitiate?: boolean): TMachine<TData, TError>;
-    invalidate(args: TArgs): void;
-    compareArgs(a: TArgs, b: TArgs): boolean;
-    /** Public key getter for API registry */
-    get key(): string | undefined;
-    /** Public keyStrategy getter for snapshot validation */
-    get keyStrategy(): "serialize" | "compare";
-    /** Serialize args to string key */
-    getSerializedKey(args: TArgs): string;
-    /** Iterate cache entries — for snapshot */
-    cacheEntries(): Iterable<[TArgs | string, CacheEntry<TData, TError>]>;
-    /** Hydrate a cache entry from snapshot data */
-    hydrateEntry(args: TArgs, machine: TMachineInstance<TData, TError>): void;
-    /** Check if cache entry exists for given args */
-    hasEntry(args: TArgs): boolean;
-    /** Pre-populate cache with data */
-    populateEntry(args: TArgs, data: TData): void;
-    /** Create an optimistic patch on a cache entry */
-    createEntryPatch(args: TArgs, patchFn: TPatchFn<TData>): {
-        commit: () => void;
-        abort: () => void;
-    } | null;
-    /** Lock a cache entry — prevent GC eviction. Returns unlock function. */
-    lockEntry(args: TArgs): {
-        unlock: () => void;
-    };
-    /** Subscribe to refresh error events (used by Agent) */
-    onRefreshError(listener: (args: TArgs, error: TError) => void): () => void;
-    /** Reset the entire cache — aborts in-flight requests, clears GC timers, completes all entries. */
-    resetCache(): void;
-    /**
-     * Schedule GC for a cache entry after cacheLifetime.
-     * Called when subscriber count drops to 0.
-     */
-    scheduleGc(args: TArgs): void;
-    /**
-     * Cancel pending GC for a cache entry.
-     * Called when a new subscriber appears.
-     */
-    cancelGc(args: TArgs): void;
-    private _cancelGcTimer;
-    private _evictEntry;
-    private _executeQuery;
-    private _executeRefresh;
-    private _buildCacheEntryOptions;
-}