@fozy-labs/rx-toolkit 0.5.4 → 0.6.2

package/dist/query-v2/core/resource/ResourceV2.js

@@ -1,464 +0,0 @@
-import { shallowEqual } from "../../../common/utils/shallowEqual";
-import { SKIP } from "../../../query-v2/lib/SKIP_TOKEN";
-import { stableStringify } from "../../../query-v2/lib/stableStringify";
-import { Batcher } from "../../../signals";
-import { CacheEntry } from "../common/CacheEntry";
-import { CacheMap } from "../common/CacheMap";
-import { LifecycleHooks } from "../common/LifecycleHooks";
-import { MachineIdle } from "../machines/MachineIdle";
-import { MachineRefreshing } from "../machines/MachineRefreshing";
-import { MachineSuccess } from "../machines/MachineSuccess";
-import { MachineWithData } from "../machines/MachineWithData";
-import { ResourceV2Agent } from "./ResourceV2Agent";
-/**
- * Cache-backed resource manager.
- * Orchestrates queries, caching, lifecycle hooks, GC, and optimistic patches for a single resource type.
- */
-export class ResourceV2 {
-    _cache;
-    _queryFn;
-    _lifecycleHooks;
-    _serializeArgs;
-    _compareArg;
-    _keyStrategy;
-    _cacheLifetime;
-    _beforeDevtoolsPush;
-    _key;
-    _keyPrefix;
-    /** In-flight queries keyed by serialized args — for dedup + abort */
-    _inFlight = new Map();
-    /** Cache lifetime timers keyed by serialized args */
-    _gcTimers = new Map();
-    /** Refresh error listeners (used by Agent for refreshError tracking) */
-    _refreshErrorListeners = new Set();
-    constructor(config) {
-        this._queryFn = config.queryFn;
-        this._serializeArgs = config.serializeArgs ?? stableStringify;
-        this._compareArg = config.compareArg ?? shallowEqual;
-        this._keyStrategy = config.keyStrategy ?? "serialize";
-        this._cacheLifetime = config.cacheLifetime ?? 60_000;
-        this._beforeDevtoolsPush = config.beforeDevtoolsPush;
-        this._key = config.key;
-        this._keyPrefix = config.keyPrefix;
-        this._cache = CacheMap.create({
-            keyStrategy: this._keyStrategy,
-            serializeArgs: this._serializeArgs,
-            compareArg: this._compareArg,
-            doCacheArgs: config.doCacheArgs ?? false,
-        });
-        this._lifecycleHooks = new LifecycleHooks({
-            onCacheEntryAdded: config.onCacheEntryAdded,
-            onQueryStarted: config.onQueryStarted,
-            serializeArgs: this._serializeArgs,
-        });
-    }
-    /**
-     * Create an agent that tracks a single cache entry with reactive state (SWR).
-     *
-     * @returns A new agent bound to this resource.
-     */
-    createAgent() {
-        return new ResourceV2Agent(this);
-    }
-    /**
-     * 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.
-     */
-    async query(args, doForce) {
-        // SKIP check
-        if (args === SKIP) {
-            throw new Error("SKIP_TOKEN is not valid for direct query()");
-        }
-        const key = this._serializeArgs(args);
-        // Cache hit — return existing entry (unless force)
-        const existing = this._cache.get(args);
-        if (existing && !doForce) {
-            const machine = existing.peek();
-            // If already success or pending or refreshing, return the entry
-            if (machine.state.status !== "idle") {
-                return existing;
-            }
-        }
-        // Query dedup — if already in-flight for same args, return same promise
-        if (!doForce) {
-            const flight = this._inFlight.get(key);
-            if (flight) {
-                return flight.promise;
-            }
-        }
-        // Cancel existing in-flight for same args (ADR-4 Layer 1)
-        const existingFlight = this._inFlight.get(key);
-        if (existingFlight) {
-            existingFlight.abortController.abort();
-            this._inFlight.delete(key);
-        }
-        // Cancel any pending GC timer for these args
-        this._cancelGcTimer(key);
-        const abortController = new AbortController();
-        const isNewEntry = !existing;
-        // Create or reuse entry inside Batcher for atomic updates
-        let cacheEntry;
-        // Set up entry and pending state
-        Batcher.run(() => {
-            if (isNewEntry || doForce) {
-                if (existing && doForce) {
-                    cacheEntry = existing;
-                    // Transition to refreshing or pending based on current state
-                    const current = cacheEntry.peek();
-                    if (current instanceof MachineSuccess) {
-                        const refreshing = current.invalidate();
-                        cacheEntry.set(refreshing);
-                    }
-                    else if (current instanceof MachineRefreshing) {
-                        // Already refreshing — it'll be re-queried
-                    }
-                    else {
-                        const idle = MachineIdle.create();
-                        const pending = idle.start(args);
-                        cacheEntry.set(pending);
-                    }
-                }
-                else {
-                    // New entry
-                    const idle = MachineIdle.create();
-                    const pending = idle.start(args);
-                    cacheEntry = new CacheEntry(pending, this._buildCacheEntryOptions(args));
-                    this._cache.set(args, cacheEntry);
-                    // Fire onCacheEntryAdded for new entries
-                    this._lifecycleHooks.fireCacheEntryAdded(args, () => cacheEntry.peek());
-                }
-            }
-            else {
-                cacheEntry = existing;
-                const current = cacheEntry.peek();
-                const pending = current.start(args);
-                cacheEntry.set(pending);
-            }
-            // Fire onQueryStarted
-            this._lifecycleHooks.fireQueryStarted(args, () => cacheEntry);
-        });
-        // Execute queryFn
-        const promise = this._executeQuery(args, key, cacheEntry, abortController);
-        this._inFlight.set(key, { promise: promise, abortController });
-        return promise;
-    }
-    /**
-     * 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, doForce) {
-        if (args === SKIP) {
-            return MachineIdle.create().state;
-        }
-        // Trigger query (fire-and-forget) and read entry signal reactively
-        const entryResult = this._cache.get(args);
-        if (!entryResult) {
-            // Initiate query
-            this.query(args, doForce);
-            // Return idle while it's being initiated
-            const newEntry = this._cache.get(args);
-            if (newEntry) {
-                return newEntry.machine$().state;
-            }
-            return MachineIdle.create().state;
-        }
-        if (doForce) {
-            this.query(args, true);
-        }
-        // Reactive read — registers signal dependency
-        return entryResult.machine$().state;
-    }
-    /**
-     * 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, doInitiate) {
-        const existing = this._cache.get(args);
-        if (existing) {
-            return existing;
-        }
-        if (doInitiate) {
-            // Fire-and-forget query initiation
-            this.query(args);
-            return this._cache.get(args) ?? null;
-        }
-        return null;
-    }
-    entry$(args, doInitiate) {
-        if (args === SKIP) {
-            return MachineIdle.create().state;
-        }
-        const existing = this._cache.get(args);
-        if (!existing && doInitiate) {
-            this.query(args);
-            const created = this._cache.get(args);
-            if (created) {
-                return created.machine$().state;
-            }
-        }
-        if (existing) {
-            return existing.machine$().state;
-        }
-        return MachineIdle.create().state;
-    }
-    invalidate(args) {
-        const existing = this._cache.get(args);
-        if (!existing)
-            return;
-        const machine = existing.peek();
-        // Only invalidate from success state
-        if (!(machine instanceof MachineSuccess))
-            return;
-        const key = this._serializeArgs(args);
-        // Abort any existing in-flight for these args (ADR-4 Layer 1)
-        const flight = this._inFlight.get(key);
-        if (flight) {
-            flight.abortController.abort();
-            this._inFlight.delete(key);
-        }
-        const abortController = new AbortController();
-        Batcher.run(() => {
-            const refreshing = machine.invalidate();
-            existing.set(refreshing);
-            this._lifecycleHooks.fireQueryStarted(args, () => existing);
-        });
-        const promise = this._executeRefresh(args, key, existing, abortController);
-        this._inFlight.set(key, { promise, abortController });
-    }
-    compareArgs(a, b) {
-        if (this._keyStrategy === "compare") {
-            return this._compareArg(a, b);
-        }
-        return this._serializeArgs(a) === this._serializeArgs(b);
-    }
-    /** Public key getter for API registry */
-    get key() {
-        return this._key;
-    }
-    /** Public keyStrategy getter for snapshot validation */
-    get keyStrategy() {
-        return this._keyStrategy;
-    }
-    /** Serialize args to string key */
-    getSerializedKey(args) {
-        return this._serializeArgs(args);
-    }
-    /** Iterate cache entries — for snapshot */
-    cacheEntries() {
-        return this._cache.entries();
-    }
-    /** Hydrate a cache entry from snapshot data */
-    hydrateEntry(args, machine) {
-        const existing = this._cache.get(args);
-        if (existing)
-            return; // Don't overwrite existing entries
-        const entry = new CacheEntry(machine, this._buildCacheEntryOptions(args));
-        this._cache.set(args, entry);
-        // Fire lifecycle for hydrated entries
-        this._lifecycleHooks.fireCacheEntryAdded(args, () => entry.peek());
-        if (machine.state.status === "success") {
-            this._lifecycleHooks.resolveCacheDataLoaded(args, machine.state.data);
-        }
-    }
-    /** Check if cache entry exists for given args */
-    hasEntry(args) {
-        return this._cache.has(args);
-    }
-    /** Pre-populate cache with data */
-    populateEntry(args, data) {
-        const existing = this._cache.get(args);
-        if (existing) {
-            const success = MachineSuccess.create(data, args);
-            existing.set(success);
-            return;
-        }
-        const success = MachineSuccess.create(data, args);
-        const entry = new CacheEntry(success, this._buildCacheEntryOptions(args));
-        this._cache.set(args, entry);
-    }
-    /** Create an optimistic patch on a cache entry */
-    createEntryPatch(args, patchFn) {
-        const entry = this._cache.get(args);
-        if (!entry)
-            return null;
-        const machine = entry.peek();
-        if (!(machine instanceof MachineWithData))
-            return null;
-        const { machine: patchedMachine, patch } = machine.createPatch(patchFn);
-        entry.set(patchedMachine);
-        return {
-            commit: () => {
-                const current = entry.peek();
-                if (current instanceof MachineWithData) {
-                    const finished = current.finishPatch("commit", patch);
-                    entry.set(finished);
-                }
-            },
-            abort: () => {
-                const current = entry.peek();
-                if (current instanceof MachineWithData) {
-                    const finished = current.finishPatch("abort", patch);
-                    entry.set(finished);
-                }
-            },
-        };
-    }
-    /** Lock a cache entry — prevent GC eviction. Returns unlock function. */
-    lockEntry(args) {
-        this.cancelGc(args);
-        return {
-            unlock: () => {
-                // Re-schedule GC (will be cancelled again if still subscribed)
-                this.scheduleGc(args);
-            },
-        };
-    }
-    /** Subscribe to refresh error events (used by Agent) */
-    onRefreshError(listener) {
-        this._refreshErrorListeners.add(listener);
-        return () => {
-            this._refreshErrorListeners.delete(listener);
-        };
-    }
-    /** Reset the entire cache — aborts in-flight requests, clears GC timers, completes all entries. */
-    resetCache() {
-        // Abort all in-flight requests
-        for (const [, flight] of this._inFlight) {
-            flight.abortController.abort();
-        }
-        this._inFlight.clear();
-        // Clear all GC timers
-        for (const [, timer] of this._gcTimers) {
-            clearTimeout(timer);
-        }
-        this._gcTimers.clear();
-        // Complete all cache entries
-        for (const entry of this._cache.values()) {
-            entry.complete();
-        }
-        // Clear lifecycle hooks
-        this._lifecycleHooks.clearAll();
-        // Clear the cache map
-        this._cache.clear();
-    }
-    /**
-     * Schedule GC for a cache entry after cacheLifetime.
-     * Called when subscriber count drops to 0.
-     */
-    scheduleGc(args) {
-        const key = this._serializeArgs(args);
-        this._cancelGcTimer(key);
-        this._gcTimers.set(key, setTimeout(() => {
-            this._gcTimers.delete(key);
-            this._evictEntry(args, key);
-        }, this._cacheLifetime));
-    }
-    /**
-     * Cancel pending GC for a cache entry.
-     * Called when a new subscriber appears.
-     */
-    cancelGc(args) {
-        const key = this._serializeArgs(args);
-        this._cancelGcTimer(key);
-    }
-    // --- Private helpers ---
-    _cancelGcTimer(key) {
-        const timer = this._gcTimers.get(key);
-        if (timer != null) {
-            clearTimeout(timer);
-            this._gcTimers.delete(key);
-        }
-    }
-    _evictEntry(args, key) {
-        const entry = this._cache.get(args);
-        if (!entry)
-            return;
-        // Abort in-flight if any
-        const flight = this._inFlight.get(key);
-        if (flight) {
-            flight.abortController.abort();
-            this._inFlight.delete(key);
-        }
-        // Fire lifecycle removal
-        this._lifecycleHooks.fireCacheEntryRemoved(args);
-        // Complete the entry (ADR-4 Layer 3)
-        entry.complete();
-        // Remove from cache
-        this._cache.delete(args);
-    }
-    async _executeQuery(args, key, cacheEntry, abortController) {
-        try {
-            const data = await this._queryFn(args, {
-                abortSignal: abortController.signal,
-            });
-            // If aborted after await, don't process result
-            if (abortController.signal.aborted) {
-                return cacheEntry;
-            }
-            Batcher.run(() => {
-                const current = cacheEntry.peek();
-                if (current.state.status === "pending") {
-                    const success = current.successHappened(data);
-                    cacheEntry.set(success);
-                }
-                else if (current.state.status === "refreshing") {
-                    const success = current.successHappened(data);
-                    cacheEntry.set(success);
-                }
-            });
-            this._lifecycleHooks.resolveCacheDataLoaded(args, data);
-            this._lifecycleHooks.resolveQueryFulfilled(data);
-        }
-        catch (error) {
-            if (abortController.signal.aborted) {
-                this._lifecycleHooks.rejectQueryFulfilled(error);
-                return cacheEntry;
-            }
-            Batcher.run(() => {
-                const current = cacheEntry.peek();
-                if (current.state.status === "pending") {
-                    const errorMachine = current.errorHappened(error);
-                    cacheEntry.set(errorMachine);
-                }
-                else if (current.state.status === "refreshing") {
-                    // ADR-2: Preserve stale data
-                    const success = current.errorHappened(error);
-                    cacheEntry.set(success);
-                    // Notify refresh error listeners (used by Agent)
-                    for (const listener of this._refreshErrorListeners) {
-                        listener(args, error);
-                    }
-                }
-            });
-            this._lifecycleHooks.rejectQueryFulfilled(error);
-        }
-        finally {
-            this._inFlight.delete(key);
-        }
-        return cacheEntry;
-    }
-    async _executeRefresh(args, key, cacheEntry, abortController) {
-        return this._executeQuery(args, key, cacheEntry, abortController);
-    }
-    _buildCacheEntryOptions(args) {
-        const parts = [];
-        if (this._keyPrefix)
-            parts.push(this._keyPrefix);
-        if (this._key)
-            parts.push(this._key);
-        parts.push(this._serializeArgs(args));
-        return {
-            keyParts: parts.length > 0 ? parts : undefined,
-            beforeDevtoolsPush: this._beforeDevtoolsPush,
-        };
-    }
-}

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

@@ -1,26 +0,0 @@
-import { type SKIP_TOKEN } from "../../../query-v2/lib/SKIP_TOKEN";
-import type { IResourceV2Agent, IResourceV2AgentState } from "../../../query-v2/types/agent.types";
-import type { ComputeFn } from "../../../signals";
-import type { ResourceV2 } from "./ResourceV2";
-/**
- * Agent that tracks a single cache entry with reactive state, designed for React hook consumption.
- * Provides SWR (stale-while-revalidate) semantics by keeping previous data while new data loads.
- */
-export declare class ResourceV2Agent<TArgs, TData, TError = Error> implements IResourceV2Agent<TArgs, TData, TError> {
-    private readonly _resource;
-    private readonly _tracking$;
-    private readonly _refreshError$;
-    private readonly _state$;
-    private readonly _unsubRefreshError;
-    private _currentArgs;
-    constructor(resource: ResourceV2<TArgs, TData, TError>);
-    /** Computed reactive state signal — projects CacheEntry machine state into a flat agent state object. */
-    get state$(): ComputeFn<IResourceV2AgentState<TArgs, TData, TError>>;
-    /**
-     * Start (or re-start) the agent with new args. Skips if args are unchanged.
-     *
-     * @param args - Query arguments, or `SKIP_TOKEN` to do nothing.
-     */
-    start(args: TArgs | SKIP_TOKEN): Promise<void>;
-    compareArgs(a: TArgs, b: TArgs): boolean;
-}

package/dist/query-v2/core/resource/ResourceV2Agent.js

@@ -1,132 +0,0 @@
-import { SKIP } from "../../../query-v2/lib/SKIP_TOKEN";
-import { Signal } from "../../../signals";
-/**
- * Agent that tracks a single cache entry with reactive state, designed for React hook consumption.
- * Provides SWR (stale-while-revalidate) semantics by keeping previous data while new data loads.
- */
-export class ResourceV2Agent {
-    _resource;
-    _tracking$;
-    _refreshError$;
-    _state$;
-    _unsubRefreshError;
-    _currentArgs = null;
-    constructor(resource) {
-        this._resource = resource;
-        // Agent signals are internal derived state for React hooks — only CacheEntry signals belong in devtools
-        this._tracking$ = Signal.state({ previous: null, current: null }, { isDisabled: true });
-        // Agent signal — excluded from devtools; only CacheEntry signals represent canonical cache state
-        this._refreshError$ = Signal.state(null, { isDisabled: true });
-        // Subscribe to refresh errors from the resource
-        this._unsubRefreshError = this._resource.onRefreshError((args, error) => {
-            if (this._currentArgs !== null && this._resource.compareArgs(this._currentArgs, args)) {
-                this._refreshError$.set(error);
-            }
-        });
-        // Agent signal — excluded from devtools; only CacheEntry signals represent canonical cache state
-        this._state$ = Signal.compute(() => {
-            const { previous, current } = this._tracking$();
-            if (!current) {
-                return {
-                    status: "idle",
-                    data: null,
-                    error: null,
-                    args: null,
-                    isLoading: false,
-                    isInitialLoading: false,
-                    isRefreshing: false,
-                    isSuccess: false,
-                    isError: false,
-                    refreshError: this._refreshError$(),
-                };
-            }
-            // Read machine$ reactively — this is the key reactive subscription
-            const machine = current.machine$();
-            const machineState = machine.state;
-            const status = machineState.status;
-            // Determine previous data for SWR
-            let previousData = null;
-            if (previous) {
-                const prevMachine = previous.machine$();
-                const prevState = prevMachine.state;
-                if (prevState.data != null) {
-                    previousData = prevState.data;
-                }
-            }
-            const currentData = machineState.data;
-            const isLoading = status === "pending" || status === "refreshing";
-            const isRefreshing = status === "refreshing";
-            // SWR: use previous data if current is loading and has no data yet
-            const data = currentData ?? (isLoading ? previousData : null);
-            const hasPreviousData = previousData !== null;
-            const isInitialLoading = isLoading && !hasPreviousData && currentData === null;
-            const isSuccess = data !== null;
-            const isError = status === "error";
-            const error = isError ? machineState.error : null;
-            return {
-                status,
-                data,
-                error,
-                args: machineState.args ?? null,
-                isLoading,
-                isInitialLoading,
-                isRefreshing,
-                isSuccess,
-                isError,
-                refreshError: this._refreshError$(),
-            };
-        }, { isDisabled: true });
-    }
-    /** Computed reactive state signal — projects CacheEntry machine state into a flat agent state object. */
-    get state$() {
-        return this._state$;
-    }
-    /**
-     * Start (or re-start) the agent with new args. Skips if args are unchanged.
-     *
-     * @param args - Query arguments, or `SKIP_TOKEN` to do nothing.
-     */
-    async start(args) {
-        // SKIP: no-op
-        if (args === SKIP) {
-            return;
-        }
-        const typedArgs = args;
-        // Same args check — skip if unchanged
-        if (this._currentArgs !== null && this._resource.compareArgs(this._currentArgs, typedArgs)) {
-            return;
-        }
-        this._currentArgs = typedArgs;
-        // Query the resource — get a cache entry
-        const entryPromise = this._resource.query(typedArgs);
-        // Get the entry synchronously from the resource
-        const entry = this._resource.entry(typedArgs);
-        // Swap previous/current
-        const oldTracking = this._tracking$.peek();
-        this._tracking$.set({
-            previous: oldTracking.current,
-            current: entry,
-        });
-        // Wait for the query to resolve and then clear previous
-        try {
-            await entryPromise;
-            // Clear refreshError on successful query completion
-            this._refreshError$.set(null);
-        }
-        catch {
-            // query() shouldn't reject, but handle gracefully
-        }
-        // Clear previous after current resolves (success or error)
-        // Only if current hasn't changed (latest-wins)
-        const currentTracking = this._tracking$.peek();
-        if (currentTracking.current === entry) {
-            this._tracking$.set({
-                previous: null,
-                current: entry,
-            });
-        }
-    }
-    compareArgs(a, b) {
-        return this._resource.compareArgs(a, b);
-    }
-}

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

@@ -1,2 +0,0 @@
-export { ResourceV2, type ResourceV2Config } from "./ResourceV2";
-export { ResourceV2Agent } from "./ResourceV2Agent";

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

@@ -1,2 +0,0 @@
-export { ResourceV2 } from "./ResourceV2";
-export { ResourceV2Agent } from "./ResourceV2Agent";

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

@@ -1,11 +0,0 @@
-export { SKIP, type SKIP_TOKEN } from "./lib/SKIP_TOKEN";
-export { NO_VALUE } from "./lib/NO_VALUE";
-export type { NO_VALUE as NO_VALUE_TYPE } from "./lib/NO_VALUE";
-export { stableStringify } from "./lib/stableStringify";
-export { Machine, type TMachineInstance, MachineIdle, MachinePending, MachineSuccess, MachineError, MachineRefreshing, MachineWithData, Patcher, CacheEntry, type CacheEntryOptions, CacheMap, type TCacheMapInstance, LifecycleHooks, ResourceV2, type ResourceV2Config, ResourceV2Agent, } from "./core";
-export { createApi } from "./api/createApi";
-export { ReactHooksPlugin } from "./plugins/ReactHooksPlugin";
-export type { IReactHooksPluginContributions } from "./plugins/ReactHooksPlugin";
-export { useResourceV2Agent, useResourceV2Ref } from "./react";
-export { getSnapshot, hydrateSnapshot, CURRENT_SNAPSHOT_VERSION } from "./snapshot/Snapshot";
-export * from "./types";

package/dist/query-v2/index.js

@@ -1,17 +0,0 @@
-// Sentinel tokens
-export { SKIP } from "./lib/SKIP_TOKEN";
-export { NO_VALUE } from "./lib/NO_VALUE";
-// Utilities
-export { stableStringify } from "./lib/stableStringify";
-// Core — Machine classes
-export { Machine, MachineIdle, MachinePending, MachineSuccess, MachineError, MachineRefreshing, MachineWithData, Patcher, CacheEntry, CacheMap, LifecycleHooks, ResourceV2, ResourceV2Agent, } from "./core";
-// API factory
-export { createApi } from "./api/createApi";
-// Plugins
-export { ReactHooksPlugin } from "./plugins/ReactHooksPlugin";
-// React hooks (standalone)
-export { useResourceV2Agent, useResourceV2Ref } from "./react";
-// Snapshot
-export { getSnapshot, hydrateSnapshot, CURRENT_SNAPSHOT_VERSION } from "./snapshot/Snapshot";
-// Types
-export * from "./types";

package/dist/query-v2/lib/NO_VALUE.d.ts

@@ -1,2 +0,0 @@
-export declare const NO_VALUE: unique symbol;
-export type NO_VALUE = typeof NO_VALUE;

package/dist/query-v2/lib/NO_VALUE.js

@@ -1 +0,0 @@
-export const NO_VALUE = Symbol("NO_VALUE");

package/dist/query-v2/lib/SKIP_TOKEN.d.ts

@@ -1,2 +0,0 @@
-export declare const SKIP: unique symbol;
-export type SKIP_TOKEN = typeof SKIP;

package/dist/query-v2/lib/SKIP_TOKEN.js

@@ -1 +0,0 @@
-export const SKIP = Symbol("SKIP");

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

@@ -1,4 +0,0 @@
-export { SKIP, type SKIP_TOKEN } from "./SKIP_TOKEN";
-export { NO_VALUE } from "./NO_VALUE";
-export type { NO_VALUE as NO_VALUE_TYPE } from "./NO_VALUE";
-export { stableStringify } from "./stableStringify";

package/dist/query-v2/lib/index.js

@@ -1,3 +0,0 @@
-export { SKIP } from "./SKIP_TOKEN";
-export { NO_VALUE } from "./NO_VALUE";
-export { stableStringify } from "./stableStringify";