@nano_kit/query 1.0.0-alpha.0 → 1.0.0-alpha.10

package/dist/index.js

@@ -1,951 +1,1040 @@
-import { batch, setMapKey, fireMapEvent, $$insert, subMapEvent, $getMapKey, clearMap, deleteMapKey, untracked, external, onMount, mountable, listen, effect, taskPromise, computed, action, onStart, effectScope, signal, readonly } from '@nano_kit/store';
-
+import { $$insert, $get, $getMapKey, Hydratables$, Hydrator$, NoopCodec, TasksRunner$, action, batch, clearMap, computed, deleteMapKey, effect, effectScope, fireMapEvent, identity, inject, isFunction, listen, mountable, onStart, readonly, setMapKey, signal, subMapEvent, taskPromise, untracked } from "@nano_kit/store";
+//#region src/settings/abortable.ts
 const abortControllers = /* @__PURE__ */ new WeakMap();
-// @__NO_SIDE_EFFECTS__
+/**
+* Returns the AbortSignal for the given RequestContext
+* @param ctx - RequestContext
+* @returns AbortSignal
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function abortSignal(ctx) {
-  let controller = abortControllers.get(ctx);
-  if (!controller) {
-    abortControllers.set(ctx, controller = new AbortController());
-  }
-  return controller.signal;
+	let controller = abortControllers.get(ctx);
+	if (!controller) abortControllers.set(ctx, controller = new AbortController());
+	return controller.signal;
 }
+/**
+* Aborts request associated with the given Promise or RequestContext
+* @param promiseOrCtx - Promise or RequestContext
+*/
 function abort(promiseOrCtx) {
-  abortControllers.get(promiseOrCtx)?.abort();
+	abortControllers.get(promiseOrCtx)?.abort();
 }
+/**
+* Aborts previous request associated with the given RequestContext
+* @param ctx - RequestContext
+*/
 function abortPrevious(ctx) {
-  abort(ctx.prevCtx);
+	abort(ctx.prevCtx);
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Make requests abortable.
+* @returns The client setting function.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function abortable() {
-  return (ctx) => {
-    if (ctx.abortable === void 0) {
-      const superRun = ctx.run;
-      ctx.run = function(requestCtx, start, onSettled, interrupt) {
-        let abortController;
-        const promise = superRun.call(
-          this,
-          requestCtx,
-          start,
-          onSettled,
-          (error) => interrupt?.(error) || abortController?.signal.aborted === true
-        );
-        if (abortController = abortControllers.get(requestCtx)) {
-          abortControllers.set(promise, abortController);
-          void promise.finally(() => abortControllers.delete(promise));
-        }
-        return promise;
-      };
-    }
-    ctx.abortable = true;
-  };
+	return (ctx) => {
+		if (ctx.abortable === void 0) {
+			const superRun = ctx.run;
+			ctx.run = function(requestCtx, start, onSettled, interrupt) {
+				let abortController;
+				const promise = superRun.call(this, requestCtx, start, onSettled, (error) => interrupt?.(error) || abortController?.signal.aborted === true);
+				if (abortController = abortControllers.get(requestCtx)) {
+					abortControllers.set(promise, abortController);
+					promise.finally(() => abortControllers.delete(promise));
+				}
+				return promise;
+			};
+		}
+		ctx.abortable = true;
+	};
 }
-
-// @__NO_SIDE_EFFECTS__
+//#endregion
+//#region src/cache.ts
+/**
+* Create a query cache key builder.
+* @param name - The cache shard name.
+* @param filter - Optional filter to process parameters before building the key.
+* @returns The cache key builder.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function queryKey(name, filter = (params) => params) {
-  const key = ((...params) => ({
-    shard: name,
-    key: JSON.stringify(filter(params))
-  }));
-  key.shard = name;
-  key.key = void 0;
-  return key;
-}
-// @__NO_SIDE_EFFECTS__
+	const key = ((...params) => ({
+		shard: name,
+		key: JSON.stringify(filter(params))
+	}));
+	key.shard = name;
+	key.key = void 0;
+	return key;
+}
+/**
+* Create an operation cache key builder with extra parameters.
+* @param name - The cache shard name.
+* @param filter - Optional filter to process parameters before building the key.
+* @returns The extras cache key builder.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function operationKey(name, filter) {
-  return /* @__PURE__ */ queryKey(name, filter);
+	return /* @__PURE__ */ queryKey(name, filter);
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Create cache getter/setter for data.
+* @param cache - The cache map.
+* @returns The data getter/setter.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function dataCacheFacade(cache) {
-  return dataCacheGetterSetter.bind(cache);
+	return dataCacheGetterSetter.bind(cache);
 }
 function dataCacheGetterSetter(key, ...value) {
-  if (value.length) {
-    const newValue = value[0];
-    this.set(key, (entry = this.initial()) => ({
-      ...entry,
-      data: typeof newValue === "function" ? newValue(entry.data) : newValue
-    }));
-  } else {
-    return this.$get(key).data;
-  }
-}
-// @__NO_SIDE_EFFECTS__
+	if (value.length) {
+		const newValue = value[0];
+		this.set(key, (entry = this.initial()) => ({
+			...entry,
+			data: isFunction(newValue) ? newValue(entry.data) : newValue
+		}));
+	} else return this.$get(key).data;
+}
+/**
+* Create cache getter for loading state.
+* @param cache - The cache map.
+* @returns The loading state getter.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function loadingCacheFacade(cache) {
-  return (key) => cache.$get(key).loading;
+	return (key) => cache.$get(key).loading;
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Create cache getter for error state.
+* @param cache - The cache map.
+* @returns The error state getter.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function errorCacheFacade(cache) {
-  return (key) => cache.$get(key).error;
+	return (key) => cache.$get(key).error;
 }
-
+//#endregion
+//#region src/settings/entities.ts
 const ENTITY_KEY = "#entity";
-const EntityKey = queryKey(ENTITY_KEY);
+const EntityKey = /* @__PURE__ */ queryKey(ENTITY_KEY);
 function isIdentifier(value) {
-  const type = typeof value;
-  return type === "number" || type === "string";
+	const type = typeof value;
+	return type === "number" || type === "string";
 }
 function isEntityRef(value) {
-  return ENTITY_KEY in value;
+	return ENTITY_KEY in value;
 }
 let currentCtx = null;
-// @__NO_SIDE_EFFECTS__
-function entity(name, id = (entity2) => entity2.id) {
-  return (idOrRefOrEntity) => {
-    if (isIdentifier(idOrRefOrEntity)) {
-      return EntityKey(name, idOrRefOrEntity);
-    }
-    if (!idOrRefOrEntity || !currentCtx) {
-      return idOrRefOrEntity;
-    }
-    if (isEntityRef(idOrRefOrEntity)) {
-      return currentCtx.$get(idOrRefOrEntity[ENTITY_KEY]).data;
-    }
-    const key = EntityKey(name, id(idOrRefOrEntity));
-    currentCtx.set(key, {
-      ...currentCtx.initial(),
-      data: idOrRefOrEntity
-    });
-    return {
-      ...idOrRefOrEntity,
-      [ENTITY_KEY]: key
-    };
-  };
-}
-// @__NO_SIDE_EFFECTS__
+/* @__NO_SIDE_EFFECTS__ */
+function entity(name, id = (entity) => entity.id) {
+	return (idOrRefOrEntity) => {
+		if (isIdentifier(idOrRefOrEntity)) return EntityKey(name, idOrRefOrEntity);
+		if (!idOrRefOrEntity || !currentCtx) return idOrRefOrEntity;
+		if (isEntityRef(idOrRefOrEntity)) return currentCtx.$get(idOrRefOrEntity[ENTITY_KEY]).data;
+		const key = EntityKey(name, id(idOrRefOrEntity));
+		currentCtx.set(key, {
+			...currentCtx.initial(),
+			data: idOrRefOrEntity
+		});
+		return {
+			...idOrRefOrEntity,
+			[ENTITY_KEY]: key
+		};
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
 function entities(mapper) {
-  return (ctx) => {
-    const safeMapper = (data) => {
-      if (data) {
-        try {
-          currentCtx = ctx;
-          return mapper(data);
-        } finally {
-          currentCtx = null;
-        }
-      }
-      return data;
-    };
-    ctx.mapComputedData = ctx.mapData = safeMapper;
-  };
+	return (ctx) => {
+		const safeMapper = (data) => {
+			if (data) try {
+				currentCtx = ctx;
+				return mapper(data);
+			} finally {
+				currentCtx = null;
+			}
+			return data;
+		};
+		ctx.mapComputedData = ctx.mapData = safeMapper;
+	};
 }
-
-// @__NO_SIDE_EFFECTS__
+//#endregion
+//#region src/map.ts
+/**
+* Check if sharded map has the key.
+* Checks full key.
+* @param map - The sharded map.
+* @param shardedKey - The sharded key.
+* @returns True if the sharded map has the key, false otherwise.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function hasShardedMapKey(map, shardedKey) {
-  const {
-    shard,
-    key
-  } = shardedKey;
-  if (key === void 0) {
-    return map.has(shard);
-  }
-  return map.get(shard)?.has(key) || false;
-}
-// @__NO_SIDE_EFFECTS__
+	const { shard, key } = shardedKey;
+	if (key === void 0) return map.has(shard);
+	return map.get(shard)?.has(key) || false;
+}
+/**
+* Get value from sharded map by key.
+* @param map - The sharded map.
+* @param shardedKey - The sharded key.
+* @returns The value or undefined if not found.
+*/
 function $getShardedMapKey(map, shardedKey) {
-  const {
-    shard,
-    key
-  } = shardedKey;
-  let shardMap;
-  if ((shardMap = map.get(shard)) === void 0) {
-    subMapEvent(map, $$insert);
-    return void 0;
-  }
-  return $getMapKey(shardMap, key);
+	const { shard, key } = shardedKey;
+	let shardMap;
+	if ((shardMap = map.get(shard)) === void 0) {
+		subMapEvent(map, $$insert);
+		return;
+	}
+	return $getMapKey(shardMap, key);
 }
+/**
+* Set value in sharded map by key.
+* If sharded key contains only shard name, sets value for all entries in the shard.
+* @param map - The sharded map.
+* @param shardedKey - The sharded key.
+* @param value - The value to set.
+*/
 function setShardedMapKey(map, shardedKey, value) {
-  const {
-    shard,
-    key
-  } = shardedKey;
-  let shardMap = map.get(shard);
-  const shardExists = shardMap !== void 0;
-  if (key === void 0) {
-    if (shardExists) {
-      batch(() => {
-        for (const params of shardMap.keys()) {
-          setMapKey(shardMap, params, value);
-        }
-      });
-    }
-    return;
-  }
-  if (!shardExists) {
-    map.set(
-      shard,
-      shardMap = /* @__PURE__ */ new Map()
-    );
-  }
-  setMapKey(shardMap, key, value);
-  if (!shardExists) {
-    fireMapEvent(map, $$insert);
-  }
+	const { shard, key } = shardedKey;
+	let shardMap = map.get(shard);
+	const shardExists = shardMap !== void 0;
+	if (key === void 0) {
+		if (shardExists) batch(() => {
+			for (const params of shardMap.keys()) setMapKey(shardMap, params, value);
+		});
+		return;
+	}
+	if (!shardExists) map.set(shard, shardMap = /* @__PURE__ */ new Map());
+	setMapKey(shardMap, key, value);
+	if (!shardExists) fireMapEvent(map, $$insert);
 }
+/**
+* Delete sharded map key.
+* If sharded key contains only shard name, deletes all entries in the shard.
+* @param map - The sharded map.
+* @param shardedKey - The sharded key.
+*/
 function deleteShardedMapKey(map, shardedKey) {
-  const {
-    shard,
-    key
-  } = shardedKey;
-  const shardMap = map.get(shard);
-  if (shardMap === void 0) {
-    return;
-  }
-  if (key === void 0) {
-    clearMap(shardMap);
-    return;
-  }
-  deleteMapKey(shardMap, key);
+	const { shard, key } = shardedKey;
+	const shardMap = map.get(shard);
+	if (shardMap === void 0) return;
+	if (key === void 0) {
+		clearMap(shardMap);
+		return;
+	}
+	deleteMapKey(shardMap, key);
 }
-
+/**
+* Clear the sharded map.
+* @param map - The sharded map.
+*/
+function clearShardedMap(map) {
+	batch(() => map.forEach(clearMap));
+	map.clear();
+}
+//#endregion
+//#region src/CacheStorage.ts
 const DEFAULT_DEDUPE_TIME = 4e3;
 const DEFAULT_CACHE_TIME = Infinity;
 const UNSET_REV = Infinity;
-// @__NO_SIDE_EFFECTS__
+/* @__NO_SIDE_EFFECTS__ */
 function revLock(rev) {
-  return rev > 0 ? rev * -1 : rev;
+	return rev > 0 ? rev * -1 : rev;
 }
-// @__NO_SIDE_EFFECTS__
+/* @__NO_SIDE_EFFECTS__ */
 function revLocked(rev) {
-  return rev < 0;
+	return rev < 0;
 }
 let revCounter = 0;
-class CacheStorage {
-  dedupeTime = DEFAULT_DEDUPE_TIME;
-  cacheTime = DEFAULT_CACHE_TIME;
-  cache = /* @__PURE__ */ new Map();
-  initial() {
-    return {
-      rev: UNSET_REV,
-      dedupes: 0,
-      expires: 0,
-      data: null,
-      error: null,
-      loading: false
-    };
-  }
-  $get(key) {
-    const cache = this.cache;
-    if (!hasShardedMapKey(cache, key)) {
-      setShardedMapKey(cache, key, this.initial());
-    }
-    const result = $getShardedMapKey(cache, key);
-    return result;
-  }
-  set(key, entry) {
-    setShardedMapKey(this.cache, key, entry);
-  }
-  /**
-   * Invalidate cache entry for the given key.
-   * If shard key is used, invalidate all entries in the shard.
-   * @param key - The cache key to invalidate.
-   */
-  invalidate(key) {
-    deleteShardedMapKey(this.cache, key);
-  }
-  /**
-   * Revalidate cache entry for the given key.
-   * If shard key is used, revalidate all entries in the shard.
-   * @param key - The cache key to revalidate.
-   */
-  revalidate(key) {
-    if (key.key === void 0 || hasShardedMapKey(this.cache, key)) {
-      this.set(key, (entry) => ({
-        ...entry,
-        rev: UNSET_REV,
-        dedupes: 0
-      }));
-    }
-  }
-  mute(entry, loadingDedupe = true, timeDedupe = true) {
-    return loadingDedupe && entry.loading || timeDedupe && entry.dedupes > Date.now() || /* @__PURE__ */ revLocked(entry.rev);
-  }
-  loading(key) {
-    const rev = ++revCounter;
-    this.set(key, (entry = this.initial()) => ({
-      ...entry,
-      rev,
-      data: entry.expires > Date.now() ? entry.data : null,
-      error: null,
-      loading: true
-    }));
-    return rev;
-  }
-  settled(key, data, error, rev) {
-    const now = Date.now();
-    this.set(key, (entry = this.initial()) => rev !== void 0 && rev !== entry.rev ? entry : {
-      ...entry,
-      dedupes: now + this.dedupeTime,
-      expires: now + this.cacheTime,
-      data: error === null ? data : entry.data,
-      error,
-      loading: false
-    });
-  }
+var CacheStorage = class {
+	dedupeTime = DEFAULT_DEDUPE_TIME;
+	cacheTime = DEFAULT_CACHE_TIME;
+	cache = /* @__PURE__ */ new Map();
+	initial() {
+		return {
+			rev: UNSET_REV,
+			dedupes: 0,
+			expires: 0,
+			data: null,
+			error: null,
+			loading: false
+		};
+	}
+	$get(key) {
+		const cache = this.cache;
+		if (!/* @__PURE__ */ hasShardedMapKey(cache, key)) setShardedMapKey(cache, key, this.initial());
+		return $getShardedMapKey(cache, key);
+	}
+	set(key, entry) {
+		setShardedMapKey(this.cache, key, entry);
+	}
+	/**
+	* Invalidate cache entry for the given key.
+	* If shard key is used, invalidate all entries in the shard.
+	* @param key - The cache key to invalidate.
+	*/
+	invalidate(key) {
+		if (key) deleteShardedMapKey(this.cache, key);
+		else clearShardedMap(this.cache);
+	}
+	/**
+	* Revalidate cache entry for the given key.
+	* If shard key is used, revalidate all entries in the shard.
+	* @param key - The cache key to revalidate.
+	*/
+	revalidate(key) {
+		if (key.key === void 0 || /* @__PURE__ */ hasShardedMapKey(this.cache, key)) this.set(key, (entry) => ({
+			...entry,
+			rev: UNSET_REV,
+			dedupes: 0
+		}));
+	}
+	mute(entry, loadingDedupe = true, timeDedupe = true) {
+		return loadingDedupe && entry.loading || timeDedupe && entry.dedupes > Date.now() || /* @__PURE__ */ revLocked(entry.rev);
+	}
+	loading(key) {
+		const rev = ++revCounter;
+		this.set(key, (entry = this.initial()) => ({
+			...entry,
+			rev,
+			data: entry.expires > Date.now() ? entry.data : null,
+			error: null,
+			loading: true
+		}));
+		return rev;
+	}
+	settled(key, data, error, rev) {
+		const now = Date.now();
+		this.set(key, (entry = this.initial()) => rev !== void 0 && rev !== entry.rev ? entry : {
+			...entry,
+			dedupes: now + this.dedupeTime,
+			expires: now + this.cacheTime,
+			data: error === null ? data : entry.data,
+			error,
+			loading: false
+		});
+	}
+};
+//#endregion
+//#region src/settings/codec.ts
+function mapEntry(entry, mapDetail, mapData) {
+	return {
+		...entry,
+		data: mapData(entry.data),
+		rev: mapDetail(entry.rev),
+		dedupes: mapDetail(entry.dedupes),
+		expires: mapDetail(entry.expires)
+	};
 }
-
+function encodeEntryData(entry, codec) {
+	return mapEntry(entry, identity, codec.encode);
+}
+function decodeEntryData(entry, codec) {
+	return mapEntry(entry, identity, codec.decode);
+}
+function encodeEntryDetails(entry) {
+	return mapEntry(entry, String, identity);
+}
+function decodeEntryDetails(entry) {
+	return mapEntry(entry, Number, identity);
+}
+function encodeEntry(entry, codec) {
+	return mapEntry(entry, String, codec.encode);
+}
+function decodeEntry(entry, codec) {
+	return mapEntry(entry, Number, codec.decode);
+}
+/**
+* Set cache entry data codec for query client.
+* @param codec - Codec used to encode and decode cached data.
+* @returns The client setting function.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function codec(codec) {
+	return (ctx) => {
+		ctx.codec = codec;
+	};
+}
+//#endregion
+//#region src/settings/persistence.ts
+/**
+* Generic persistent storage client setting.
+* @param storage - The storage implementation to use for persistence.
+* @param lifetime - How long to keep entries in storage in milliseconds.
+* @returns The client setting function.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function persistence(storage, lifetime) {
+	return (ctx) => {
+		if (!storage) return;
+		if (ctx.persistenceLifetime === void 0) {
+			const superGet = ctx.$get;
+			const superSet = ctx.set;
+			const superInvalidate = ctx.invalidate;
+			ctx.$get = function(key) {
+				const cache = this.cache;
+				const hasKey = /* @__PURE__ */ hasShardedMapKey(cache, key);
+				const entry = superGet.call(this, key);
+				if (hasKey) return entry;
+				superSet.call(this, key, {
+					...entry,
+					rev: /* @__PURE__ */ revLock(entry.rev)
+				});
+				this.task(storage.get(key).then((storedEntry) => superSet.call(this, key, {
+					...entry,
+					...storedEntry && decodeEntryData(storedEntry, this.codec),
+					rev: UNSET_REV
+				})));
+				return superGet.call(this, key);
+			};
+			function saveSingleEntry(key) {
+				const entry = untracked(superGet.bind(this, key));
+				if (entry && !entry.loading && !entry.error && !/* @__PURE__ */ revLocked(entry.rev)) this.task(storage.set(key, encodeEntryData(entry, this.codec), this.persistenceLifetime));
+			}
+			ctx.set = function(cacheKey, entry) {
+				superSet.call(this, cacheKey, entry);
+				const { shard, key } = cacheKey;
+				if (key !== void 0) saveSingleEntry.call(this, cacheKey);
+				else {
+					const shardMap = this.cache.get(shard);
+					if (shardMap) for (const key of shardMap.keys()) saveSingleEntry.call(this, {
+						shard,
+						key
+					});
+				}
+			};
+			ctx.invalidate = function(key) {
+				superInvalidate.call(this, key);
+				this.task(storage.delete(key));
+			};
+		}
+		ctx.persistenceLifetime = lifetime;
+	};
+}
+//#endregion
+//#region src/settings/indexedDbStorage.ts
 const DB_NAME = "nano_kit";
 const STORE_NAME = "query";
-const DB_VERSION = 1;
 function connect() {
-  return new Promise((resolve) => {
-    const request = indexedDB.open(DB_NAME, DB_VERSION);
-    request.onerror = () => resolve(null);
-    request.onsuccess = () => resolve(request.result);
-    request.onupgradeneeded = () => {
-      const db = request.result;
-      if (!db.objectStoreNames.contains(STORE_NAME)) {
-        const store = db.createObjectStore(STORE_NAME, {
-          keyPath: ["shard", "key"]
-        });
-        store.createIndex("shard", "shard", {
-          unique: false
-        });
-      }
-    };
-  });
+	return new Promise((resolve) => {
+		const request = indexedDB.open(DB_NAME, 1);
+		request.onerror = () => resolve(null);
+		request.onsuccess = () => resolve(request.result);
+		request.onupgradeneeded = () => {
+			const db = request.result;
+			if (!db.objectStoreNames.contains("query")) db.createObjectStore(STORE_NAME, { keyPath: ["shard", "key"] }).createIndex("shard", "shard", { unique: false });
+		};
+	});
 }
 async function SELECT(connection, key) {
-  const db = await connection;
-  if (!db) {
-    return null;
-  }
-  return new Promise((resolve) => {
-    const transaction = db.transaction(STORE_NAME, "readonly");
-    const store = transaction.objectStore(STORE_NAME);
-    const request = store.get([key.shard, key.key]);
-    request.onerror = () => resolve(null);
-    request.onsuccess = () => {
-      const result = request.result;
-      if (!result) {
-        resolve(null);
-        return;
-      }
-      const now = Date.now();
-      if (result.expires < now || result.data.expires < now) {
-        void DELETE(connection, key);
-        resolve(null);
-        return;
-      }
-      resolve(result.data);
-    };
-  });
+	const db = await connection;
+	if (!db) return null;
+	return new Promise((resolve) => {
+		const request = db.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME).get([key.shard, key.key]);
+		request.onerror = () => resolve(null);
+		request.onsuccess = () => {
+			const result = request.result;
+			if (!result) {
+				resolve(null);
+				return;
+			}
+			const now = Date.now();
+			if (result.expires < now || result.data.expires < now) {
+				DELETE(connection, key);
+				resolve(null);
+				return;
+			}
+			resolve(result.data);
+		};
+	});
 }
 async function SET(connection, cacheKey, entry, lifetime) {
-  const db = await connection;
-  if (!db) {
-    return;
-  }
-  return new Promise((resolve) => {
-    const {
-      shard,
-      key
-    } = cacheKey;
-    const transaction = db.transaction(STORE_NAME, "readwrite");
-    const store = transaction.objectStore(STORE_NAME);
-    const storedEntry = {
-      shard,
-      key,
-      data: entry,
-      expires: Date.now() + lifetime
-    };
-    const request = store.put(storedEntry);
-    request.onerror = () => resolve();
-    request.onsuccess = () => resolve();
-  });
+	const db = await connection;
+	if (!db) return;
+	return new Promise((resolve) => {
+		const { shard, key } = cacheKey;
+		const store = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME);
+		const storedEntry = {
+			shard,
+			key,
+			data: entry,
+			expires: Date.now() + lifetime
+		};
+		const request = store.put(storedEntry);
+		request.onerror = () => resolve();
+		request.onsuccess = () => resolve();
+	});
 }
 async function DELETE(connection, cacheKey) {
-  const db = await connection;
-  if (!db) {
-    return;
-  }
-  return new Promise((resolve) => {
-    const {
-      shard,
-      key
-    } = cacheKey;
-    const transaction = db.transaction(STORE_NAME, "readwrite");
-    const store = transaction.objectStore(STORE_NAME);
-    if (key === void 0) {
-      const index = store.index("shard");
-      const range = IDBKeyRange.only(shard);
-      const request = index.openCursor(range);
-      request.onerror = () => resolve();
-      request.onsuccess = () => {
-        const cursor = request.result;
-        if (cursor) {
-          cursor.delete();
-          cursor.continue();
-        } else {
-          resolve();
-        }
-      };
-    } else {
-      const request = store.delete([shard, key]);
-      request.onerror = () => resolve();
-      request.onsuccess = () => resolve();
-    }
-  });
-}
-// @__NO_SIDE_EFFECTS__
-function indexedDbStorage(lifetime) {
-  return (ctx) => {
-    if (typeof indexedDB === "undefined") {
-      return;
-    }
-    if (ctx.indexedDbStorageLifetime === void 0) {
-      let saveSingleEntry = function(key) {
-        const entry = untracked(() => superGet.call(this, key));
-        if (entry && !entry.loading && !revLocked(entry.rev)) {
-          void this.task(SET(db, key, entry, this.indexedDbStorageLifetime));
-        }
-      };
-      const superGet = ctx.$get;
-      const superSet = ctx.set;
-      const superInvalidate = ctx.invalidate;
-      const db = connect();
-      ctx.$get = function(key) {
-        const cache = this.cache;
-        const hasKey = hasShardedMapKey(cache, key);
-        const entry = superGet.call(this, key);
-        if (hasKey) {
-          return entry;
-        }
-        superSet.call(this, key, {
-          ...entry,
-          rev: revLock(entry.rev)
-        });
-        void this.task(SELECT(db, key).then((storedEntry) => superSet.call(this, key, {
-          ...entry,
-          ...storedEntry,
-          rev: UNSET_REV
-        })));
-        return superGet.call(this, key);
-      };
-      ctx.set = function(cacheKey, entry) {
-        superSet.call(this, cacheKey, entry);
-        const {
-          shard,
-          key
-        } = cacheKey;
-        if (key !== void 0) {
-          saveSingleEntry.call(this, cacheKey);
-        } else {
-          const shardMap = this.cache.get(shard);
-          if (shardMap) {
-            for (const key2 of shardMap.keys()) {
-              saveSingleEntry.call(this, {
-                shard,
-                key: key2
-              });
-            }
-          }
-        }
-      };
-      ctx.invalidate = function(key) {
-        superInvalidate.call(this, key);
-        void this.task(DELETE(db, key));
-      };
-    }
-    ctx.indexedDbStorageLifetime = lifetime;
-  };
+	const db = await connection;
+	if (!db) return;
+	return new Promise((resolve) => {
+		const store = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME);
+		if (!cacheKey) {
+			const request = store.clear();
+			request.onerror = () => resolve();
+			request.onsuccess = () => resolve();
+		} else {
+			const { shard, key } = cacheKey;
+			if (key === void 0) {
+				const index = store.index("shard");
+				const range = IDBKeyRange.only(shard);
+				const request = index.openCursor(range);
+				request.onerror = () => resolve();
+				request.onsuccess = () => {
+					const cursor = request.result;
+					if (cursor) {
+						cursor.delete();
+						cursor.continue();
+					} else resolve();
+				};
+			} else {
+				const request = store.delete([shard, key]);
+				request.onerror = () => resolve();
+				request.onsuccess = () => resolve();
+			}
+		}
+	});
 }
-
-// @__NO_SIDE_EFFECTS__
+/**
+* IndexedDB adapter for persistent storage.
+* @returns IndexedDB storage implementation or null if IndexedDB is not supported.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function indexedDbStorage() {
+	if (typeof indexedDB === "undefined") return null;
+	const db = connect();
+	return {
+		get(key) {
+			return SELECT(db, key);
+		},
+		set(cacheKey, entry, lifetime) {
+			return SET(db, cacheKey, entry, lifetime);
+		},
+		delete(cacheKey) {
+			return DELETE(db, cacheKey);
+		}
+	};
+}
+//#endregion
+//#region src/utils.ts
+/* @__NO_SIDE_EFFECTS__ */
 function addFn(prevFn, fn) {
-  if (prevFn === void 0) {
-    return fn;
-  }
-  return function(...args) {
-    prevFn.apply(this, args);
-    fn.apply(this, args);
-  };
+	if (prevFn === void 0) return fn;
+	return function(...args) {
+		prevFn.apply(this, args);
+		fn.apply(this, args);
+	};
 }
 function settle(promise, onSettled) {
-  return promise.then(
-    onSettled,
-    (error) => onSettled(void 0, error)
-  );
-}
-
-const $windowVisible = external(($windowVisible2) => {
-  if (typeof document === "undefined") {
-    $windowVisible2(true);
-    return;
-  }
-  const set = () => $windowVisible2(!document.hidden);
-  set();
-  onMount(mountable($windowVisible2), () => {
-    document.addEventListener("visibilitychange", set);
-    return () => {
-      document.removeEventListener("visibilitychange", set);
-    };
-  });
-});
-// @__NO_SIDE_EFFECTS__
-function revalidateOnFocus() {
-  return (ctx) => {
-    if (ctx.revalidateOnFocusEnabled === void 0) {
-      ctx.mounted = addFn(ctx.mounted, function() {
-        listen($windowVisible, (visible) => {
-          if (visible) {
-            this.revalidate(this.$key());
-          }
-        });
-      });
-    }
-    ctx.revalidateOnFocusEnabled = true;
-  };
-}
-
-// @__NO_SIDE_EFFECTS__
-function revalidateOnInterval(interval) {
-  return (ctx) => {
-    if (ctx.revalidateInterval === void 0) {
-      ctx.mounted = addFn(ctx.mounted, function() {
-        effect(() => {
-          const id = setInterval(() => {
-            this.revalidate(this.$key());
-          }, this.revalidateInterval);
-          return () => clearInterval(id);
-        });
-      });
-    }
-    ctx.revalidateInterval = interval;
-  };
+	return promise.then(onSettled, (error) => onSettled(void 0, error));
 }
-
-const $networkOnline = external(($networkOnline2) => {
-  if (typeof navigator === "undefined") {
-    $networkOnline2(true);
-    return;
-  }
-  const set = () => $networkOnline2(navigator.onLine);
-  set();
-  onMount(mountable($networkOnline2), () => {
-    window.addEventListener("online", set);
-    window.addEventListener("offline", set);
-    return () => {
-      window.removeEventListener("online", set);
-      window.removeEventListener("offline", set);
-    };
-  });
-});
-// @__NO_SIDE_EFFECTS__
-function revalidateOnReconnect() {
-  return (ctx) => {
-    if (ctx.revalidateOnReconnectEnabled === void 0) {
-      ctx.mounted = addFn(ctx.mounted, function() {
-        listen($networkOnline, (online) => {
-          if (online) {
-            this.revalidate(this.$key());
-          }
-        });
-      });
-    }
-    ctx.revalidateOnReconnectEnabled = true;
-  };
+//#endregion
+//#region src/settings/revalidateOn.ts
+/**
+* Revalidate the query when the reactive condition becomes true.
+* @returns The client setting function.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function revalidateOn(...conditions) {
+	return (ctx) => {
+		if (ctx.revalidateOn === void 0) ctx.revalidateOn = /* @__PURE__ */ new Set();
+		conditions.forEach(($condition) => {
+			if (!ctx.revalidateOn.has($condition)) {
+				ctx.mounted = /* @__PURE__ */ addFn(ctx.mounted, function() {
+					listen($condition, (visible) => {
+						if (visible) this.revalidate(this.$key());
+					});
+				});
+				ctx.revalidateOn.add($condition);
+			}
+		});
+	};
 }
-
-// @__NO_SIDE_EFFECTS__
+//#endregion
+//#region src/settings/retryOnError.ts
+/* @__NO_SIDE_EFFECTS__ */
 function defaultCalcRetryDelay(retryCount) {
-  return (
-    // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-    ~~((Math.random() + 0.5) * (1 << (retryCount < 8 ? retryCount : 8))) * 2e3
-  );
+	return ~~((Math.random() + .5) * (1 << (retryCount < 8 ? retryCount : 8))) * 2e3;
 }
 function getRetryCount(ctx, key) {
-  return ctx.retryCounts?.get(key.key) || 0;
+	return ctx.retryCounts?.get(key.key) || 0;
 }
 function setRetryCount(ctx, key, count) {
-  (ctx.retryCounts ??= /* @__PURE__ */ new Map()).set(key.key, count);
+	(ctx.retryCounts ??= /* @__PURE__ */ new Map()).set(key.key, count);
 }
 function clearRetryCount(ctx, key) {
-  ctx.retryCounts?.delete(key.key);
+	ctx.retryCounts?.delete(key.key);
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Retry the query on error with exponential backoff.
+* @param calcRetryDelay - Function to calculate the delay before retrying.
+* @returns The client setting function.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function retryOnError(calcRetryDelay = defaultCalcRetryDelay) {
-  return (ctx) => {
-    if (ctx.calcRetryDelay === void 0) {
-      const superRun = ctx.run;
-      ctx.run = function(queryCtx, start, onSettled, interrupt) {
-        clearTimeout(this.retryTimeoutId);
-        const promise = superRun.call(this, queryCtx, start, onSettled, interrupt);
-        if (!("shard" in queryCtx)) {
-          return promise;
-        }
-        void this.task(promise.then(
-          (result) => {
-            const error = result?.[1];
-            if (!error) {
-              clearRetryCount(this, queryCtx);
-            } else {
-              const retryCount = getRetryCount(this, queryCtx) + 1;
-              const delay = this.calcRetryDelay(retryCount, error);
-              this.retryTimeoutId = setTimeout(() => {
-                this.invalidate(queryCtx);
-                setRetryCount(this, queryCtx, retryCount);
-              }, delay);
-            }
-          }
-        ));
-        return promise;
-      };
-    }
-    ctx.calcRetryDelay = calcRetryDelay;
-  };
+	return (ctx) => {
+		if (ctx.calcRetryDelay === void 0) {
+			const superRun = ctx.run;
+			ctx.run = function(queryCtx, start, onSettled, interrupt) {
+				clearTimeout(this.retryTimeoutId);
+				const promise = superRun.call(this, queryCtx, start, onSettled, interrupt);
+				if (!("shard" in queryCtx)) return promise;
+				this.task(promise.then((result) => {
+					const error = result?.[1];
+					if (!error) clearRetryCount(this, queryCtx);
+					else {
+						const retryCount = getRetryCount(this, queryCtx) + 1;
+						const delay = this.calcRetryDelay(retryCount, error);
+						this.retryTimeoutId = setTimeout(() => {
+							this.invalidate(queryCtx);
+							setRetryCount(this, queryCtx, retryCount);
+						}, delay);
+					}
+				}));
+				return promise;
+			};
+		}
+		ctx.calcRetryDelay = calcRetryDelay;
+	};
 }
-
-class ClientContext extends CacheStorage {
-  $key = void 0;
-  $disabled = void 0;
-  loadingDedupe = true;
-  timeDedupe = true;
-  onEveryError = void 0;
-  task(task) {
-    return taskPromise(task);
-  }
-  mapData(data) {
-    return data;
-  }
-  mapComputedData(data) {
-    return data;
-  }
-  mapError(error) {
-    return error?.message;
-  }
-  mounted() {
-  }
-  mute(entry) {
-    return this.$disabled?.() === true || super.mute(entry, this.loadingDedupe, this.timeDedupe);
-  }
-  run(requestCtx, start, onSettled, interrupt) {
-    const {
-      mapData,
-      mapError: mapError2
-    } = this;
-    return this.task(settle(start(), (data, error) => {
-      if (error && interrupt?.(error)) {
-        return;
-      }
-      const dataOrNull = error ? null : mapData(data);
-      const errorString = error ? mapError2(error) : null;
-      onSettled(dataOrNull, errorString);
-      requestCtx.settled(data, error);
-      this.handleError(error, requestCtx.stopErrorPropagation);
-      return [data, error];
-    }));
-  }
-  handleError(error, stopped) {
-    if (error !== void 0) {
-      this.onEveryError?.(error, stopped);
-    }
-  }
-}
-// @__NO_SIDE_EFFECTS__
+//#endregion
+//#region src/settings/hydratable.ts
+const id = "@nano_kit/query";
+function encode({ cache, codec }) {
+	const encoded = [];
+	cache.forEach((shard, shardKey) => {
+		shard.forEach(($signal, key) => {
+			const value = $signal?.();
+			if (value !== void 0) encoded.push([
+				shardKey,
+				key,
+				encodeEntry(value, codec)
+			]);
+		});
+	});
+	return encoded;
+}
+function decode({ cache, codec }, encoded) {
+	encoded.forEach(([shard, key, value]) => setShardedMapKey(cache, {
+		shard,
+		key
+	}, decodeEntry(value, codec)));
+}
+/**
+* Make client cache hydratable.
+* Without arguments, it will try to resolve {@link Hydrator$} and {@link Hydratables$} from the injection context.
+* @param hydrator - Optional hydrator to use for rehydrating the cache. Pass `null` to skip hydration and only register for dehydration.
+* @param hydratables - Optional map to register the cache collector for dehydration.
+* @returns The client setting function.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function hydratable(hydrator, hydratables) {
+	return (ctx) => {
+		if (!ctx.hydratable) {
+			const finalHydrator = hydrator === void 0 ? inject(Hydrator$) : hydrator;
+			if (finalHydrator) finalHydrator.pull(id, (value) => decode(ctx, value));
+			else {
+				const finalHydratables = hydratables === void 0 ? inject(Hydratables$) : hydratables;
+				if (finalHydratables) finalHydratables.set(id, () => encode(ctx));
+			}
+		}
+		ctx.hydratable = true;
+	};
+}
+//#endregion
+//#region src/ClientContext.ts
+var ClientContext = class extends CacheStorage {
+	$key = void 0;
+	$disabled = void 0;
+	loadingDedupe = true;
+	timeDedupe = true;
+	onEveryError = void 0;
+	codec = NoopCodec;
+	task(task) {
+		return taskPromise(task);
+	}
+	mapData(data) {
+		return data;
+	}
+	mapComputedData(data) {
+		return data;
+	}
+	mapError(error) {
+		return error?.message;
+	}
+	mounted() {}
+	mute(entry) {
+		return this.$disabled?.() === true || super.mute(entry, this.loadingDedupe, this.timeDedupe);
+	}
+	run(requestCtx, start, onSettled, interrupt) {
+		const { mapData, mapError } = this;
+		return this.task(settle(start(), (data, error) => {
+			if (error && interrupt?.(error)) return;
+			const mappedData = mapData(data);
+			onSettled(error ? null : mappedData, error ? mapError(error) : null);
+			requestCtx.settled(mappedData, error);
+			this.handleError(error, requestCtx.stopErrorPropagation);
+			return [mappedData, error];
+		}));
+	}
+	handleError(error, stopped) {
+		if (error !== void 0) this.onEveryError?.(error, stopped);
+	}
+};
+/* @__NO_SIDE_EFFECTS__ */
 function forkMutationClient(ctx, settings = []) {
-  const child = Object.create(ctx);
-  for (const setting of settings) {
-    setting(child);
-  }
-  return child;
+	const child = Object.create(ctx);
+	for (const setting of settings) setting(child);
+	return child;
 }
-// @__NO_SIDE_EFFECTS__
+/* @__NO_SIDE_EFFECTS__ */
 function forkQueryClient(ctx, $key, settings = []) {
-  const child = Object.create(ctx);
-  child.$key = $key;
-  for (const setting of settings) {
-    setting(child);
-  }
-  return child;
-}
-// @__NO_SIDE_EFFECTS__
+	const child = Object.create(ctx);
+	child.$key = $key;
+	for (const setting of settings) setting(child);
+	return child;
+}
+/**
+* Set dedupe time in which identical requests are deduped.
+* @param time - Dedupe time in milliseconds.
+* @returns The client setting function.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function dedupeTime(time) {
-  return (ctx) => ctx.dedupeTime = time;
+	return (ctx) => ctx.dedupeTime = time;
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Set cache time for cached query results.
+* @param time - Cache time in milliseconds.
+* @returns The client setting function.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function cacheTime(time) {
-  return (ctx) => ctx.cacheTime = time;
+	return (ctx) => ctx.cacheTime = time;
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Map error object to string.
+* @param fn - Function to map error to string.
+* @returns The client setting function.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function mapError(fn) {
-  return (ctx) => ctx.mapError = fn;
+	return (ctx) => ctx.mapError = fn;
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Register a callback to be called on every error.
+* @param fn - The error callback.
+* @returns The client setting function.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function onEveryError(fn) {
-  return (ctx) => ctx.onEveryError = addFn(ctx.onEveryError, fn);
+	return (ctx) => ctx.onEveryError = /* @__PURE__ */ addFn(ctx.onEveryError, fn);
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Disable requests when the signal is true.
+* @param $disabled - Readable signal indicating whether requests are disabled.
+* @returns The client setting function.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function disabled($disabled) {
-  return (ctx) => ctx.$disabled = $disabled;
+	return (ctx) => ctx.$disabled = $disabled;
 }
-// @__NO_SIDE_EFFECTS__
+/* @__NO_SIDE_EFFECTS__ */
 function dedupe(loading, time = loading) {
-  return (ctx) => {
-    ctx.loadingDedupe = loading;
-    ctx.timeDedupe = time;
-  };
+	return (ctx) => {
+		ctx.loadingDedupe = loading;
+		ctx.timeDedupe = time;
+	};
 }
-// @__NO_SIDE_EFFECTS__
-function tasks(runner) {
-  return (ctx) => ctx.task = runner;
+/**
+* Set task runner for handling tasks.
+* Without arguments, it will try to resolve a tasks runner from the current injection context.
+* @param runner - The tasks runner function.
+* @returns The client setting function.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function tasks(runner = inject(TasksRunner$)) {
+	return (ctx) => ctx.task = runner;
 }
-
-class RequestContext {
-  onSuccess = void 0;
-  onError = void 0;
-  onSettled = void 0;
-  stopErrorPropagation = false;
-  prevCtx = void 0;
-  constructor(prevCtx) {
-    if (this.prevCtx = prevCtx) {
-      prevCtx.prevCtx = void 0;
-    }
-  }
-  settled(data, error) {
-    this.onSettled?.(data, error);
-    if (error !== void 0) {
-      this.onError?.(error);
-    } else {
-      this.onSuccess?.(data);
-    }
-  }
-}
-class QueryContext extends RequestContext {
-  shard;
-  key;
-  P;
-  R;
-  constructor(key, prevCtx) {
-    super(prevCtx);
-    this.shard = key.shard;
-    this.key = key.key;
-  }
+//#endregion
+//#region src/settings/ssr.ts
+/**
+* Client setting for enabling SSR support.
+* It combines tasks management and cache hydration to ensure that queries can be executed on the server and their results can be sent to the client for hydration.
+* Should be called inside injection context.
+* @returns The client setting function.
+*/
+function ssr() {
+	const tasksSetting = /* @__PURE__ */ tasks();
+	const hydratableSetting = /* @__PURE__ */ hydratable();
+	return (ctx) => {
+		tasksSetting(ctx);
+		hydratableSetting(ctx);
+	};
 }
+//#endregion
+//#region src/RequestContext.ts
+var RequestContext = class {
+	onSuccess = void 0;
+	onError = void 0;
+	onSettled = void 0;
+	stopErrorPropagation = false;
+	prevCtx = void 0;
+	constructor(prevCtx) {
+		if (this.prevCtx = prevCtx) prevCtx.prevCtx = void 0;
+	}
+	settled(data, error) {
+		this.onSettled?.(data, error);
+		if (error !== void 0) this.onError?.(error);
+		else this.onSuccess?.(data);
+	}
+};
+var QueryContext = class extends RequestContext {
+	shard;
+	key;
+	P;
+	R;
+	constructor(key, prevCtx) {
+		super(prevCtx);
+		this.shard = key.shard;
+		this.key = key.key;
+	}
+};
+/**
+* Add a success callback to the query context.
+* @param ctx - The query context.
+* @param fn - The success callback.
+*/
 function onSuccess(ctx, fn) {
-  ctx.onSuccess = addFn(ctx.onSuccess, fn);
+	ctx.onSuccess = /* @__PURE__ */ addFn(ctx.onSuccess, fn);
 }
+/**
+* Add an error callback to the query context.
+* @param ctx - The query context.
+* @param fn - The error callback.
+*/
 function onError(ctx, fn) {
-  ctx.onError = addFn(ctx.onError, fn);
+	ctx.onError = /* @__PURE__ */ addFn(ctx.onError, fn);
 }
+/**
+* Add a settled callback to the query context.
+* @param ctx - The query context.
+* @param fn - The settled callback.
+*/
 function onSettled(ctx, fn) {
-  ctx.onSettled = addFn(ctx.onSettled, fn);
+	ctx.onSettled = /* @__PURE__ */ addFn(ctx.onSettled, fn);
 }
+/**
+* Mark error as "stopped", so error will be passed to onEveryError with stopped=true.
+* @param ctx - The query context.
+*/
 function stopErrorPropagation(ctx) {
-  ctx.stopErrorPropagation = true;
+	ctx.stopErrorPropagation = true;
 }
-
-// @__NO_SIDE_EFFECTS__
+//#endregion
+//#region src/queries/base.ts
+/* @__NO_SIDE_EFFECTS__ */
 function baseQuery(rootCtx, key, params, fn, settings) {
-  const $params = computed(() => params.map(($signal) => $signal()));
-  const $key = computed((prevKey) => {
-    const nextKey = key(...$params());
-    if (prevKey && prevKey.shard === nextKey.shard && prevKey.key === nextKey.key) {
-      return prevKey;
-    }
-    return nextKey;
-  });
-  const clientCtx = forkQueryClient(rootCtx, $key, settings);
-  const $entry = computed(() => clientCtx.$get($key()));
-  const $rev = computed((v = 0) => $entry().rev === UNSET_REV ? v + 1 : v);
-  const { mapComputedData } = clientCtx;
-  const $data = mountable(computed(() => mapComputedData($entry().data)));
-  const $error = computed(() => $entry().error);
-  const $loading = computed(() => $entry().loading);
-  let prevQueryCtx;
-  const fetch = action((...extraParams) => {
-    if (clientCtx.mute($entry())) {
-      return Promise.resolve();
-    }
-    const key2 = $key();
-    const params2 = $params();
-    const queryCtx = prevQueryCtx = new QueryContext(key2, prevQueryCtx);
-    let rev;
-    return clientCtx.run(
-      queryCtx,
-      () => {
-        rev = clientCtx.loading(key2);
-        return fn(...params2, ...extraParams, queryCtx);
-      },
-      (data, error) => clientCtx.settled(key2, data, error, rev)
-    );
-  });
-  return {
-    clientCtx,
-    fetch,
-    $params,
-    $key,
-    $rev,
-    $data,
-    $error,
-    $loading
-  };
+	const $params = computed(() => params.map($get));
+	const $key = computed((prevKey) => {
+		const nextKey = key(...$params());
+		if (prevKey && prevKey.shard === nextKey.shard && prevKey.key === nextKey.key) return prevKey;
+		return nextKey;
+	});
+	const clientCtx = /* @__PURE__ */ forkQueryClient(rootCtx, $key, settings);
+	const $entry = computed(() => clientCtx.$get($key()));
+	/**
+	* Changes on every entry rev reset
+	*/
+	const $rev = computed((v = 0) => $entry().rev === Infinity ? v + 1 : v);
+	const { mapComputedData } = clientCtx;
+	const $data = mountable(computed(() => mapComputedData($entry().data)));
+	const $error = computed(() => $entry().error);
+	const $loading = computed(() => $entry().loading);
+	let prevQueryCtx;
+	return {
+		clientCtx,
+		fetch: action((...extraParams) => {
+			if (clientCtx.mute($entry())) return Promise.resolve();
+			const key = $key();
+			const params = $params();
+			const queryCtx = prevQueryCtx = new QueryContext(key, prevQueryCtx);
+			let rev;
+			return clientCtx.run(queryCtx, () => {
+				rev = clientCtx.loading(key);
+				return fn(...params, ...extraParams, queryCtx);
+			}, (data, error) => clientCtx.settled(key, data, error, rev));
+		}),
+		$params,
+		$key,
+		$rev,
+		$data,
+		$error,
+		$loading
+	};
 }
-
-// @__NO_SIDE_EFFECTS__
+//#endregion
+//#region src/queries/query.ts
+/* @__NO_SIDE_EFFECTS__ */
 function query(key, params, fn, settings) {
-  const {
-    clientCtx,
-    fetch,
-    $params,
-    $key,
-    $rev,
-    $data,
-    $error,
-    $loading
-  } = baseQuery(this, key, params, fn, settings);
-  onStart($data, () => effectScope(() => {
-    effect(() => {
-      $rev();
-      $params();
-      clientCtx.$disabled?.();
-      void fetch();
-    });
-    clientCtx.mounted();
-  }));
-  return [$data, $error, $loading, $key];
+	const { clientCtx, fetch, $params, $key, $rev, $data, $error, $loading } = /* @__PURE__ */ baseQuery(this, key, params, fn, settings);
+	onStart($data, () => effectScope(() => {
+		effect(() => {
+			$rev();
+			$params();
+			clientCtx.$disabled?.();
+			fetch();
+		});
+		clientCtx.mounted();
+	}));
+	return [
+		$data,
+		$error,
+		$loading,
+		$key
+	];
 }
-
-// @__NO_SIDE_EFFECTS__
+//#endregion
+//#region src/queries/infinite.ts
+/* @__NO_SIDE_EFFECTS__ */
 function infinite(key, params, next, fn, settings) {
-  const {
-    clientCtx,
-    fetch,
-    $params,
-    $key,
-    $rev,
-    $data,
-    $error,
-    $loading
-  } = baseQuery(this, key, params, async (...args) => {
-    const queryCtx = args[args.length - 1];
-    const data = clientCtx.$get(queryCtx).data;
-    const page = await fn(...args);
-    const nextValue = next(page);
-    return {
-      pages: [...data?.pages || [], page],
-      next: nextValue,
-      more: Boolean(nextValue)
-    };
-  }, settings);
-  const initialTimeDedupe = clientCtx.timeDedupe;
-  const fetchNext = action(() => {
-    const data = $data();
-    if (!data?.more) {
-      return Promise.resolve();
-    }
-    clientCtx.timeDedupe = false;
-    return fetch(data.next);
-  });
-  onStart($data, () => effectScope(() => {
-    effect(() => {
-      $rev();
-      $params();
-      clientCtx.$disabled?.();
-      clientCtx.timeDedupe = initialTimeDedupe;
-      void fetch(void 0);
-    });
-    clientCtx.mounted();
-  }));
-  return [fetchNext, $data, $error, $loading, $key];
+	const { clientCtx, fetch, $params, $key, $rev, $data, $error, $loading } = /* @__PURE__ */ baseQuery(this, key, params, async (...args) => {
+		const queryCtx = args[args.length - 1];
+		const cursor = args[args.length - 2];
+		const data = clientCtx.$get(queryCtx).data;
+		const page = await fn(...args);
+		const nextValue = next(page);
+		return {
+			pages: cursor === void 0 ? [page] : [...data?.pages || [], page],
+			next: nextValue,
+			more: Boolean(nextValue)
+		};
+	}, settings);
+	const initialTimeDedupe = clientCtx.timeDedupe;
+	const fetchNext = action(() => {
+		const data = $data();
+		if (!data?.more) return Promise.resolve();
+		clientCtx.timeDedupe = false;
+		return fetch(data.next);
+	});
+	onStart($data, () => effectScope(() => {
+		effect(() => {
+			$rev();
+			$params();
+			clientCtx.$disabled?.();
+			clientCtx.timeDedupe = initialTimeDedupe;
+			fetch(void 0);
+		});
+		clientCtx.mounted();
+	}));
+	return [
+		fetchNext,
+		$data,
+		$error,
+		$loading,
+		$key
+	];
 }
-
-// @__NO_SIDE_EFFECTS__
+//#endregion
+//#region src/queries/operation.ts
+/* @__NO_SIDE_EFFECTS__ */
 function operation(key, params, fn, settings = []) {
-  const {
-    clientCtx,
-    fetch,
-    $key,
-    $data,
-    $error,
-    $loading
-  } = baseQuery(this, key, params, fn, [dedupe(true, false), ...settings]);
-  onStart($data, () => effectScope(() => clientCtx.mounted()));
-  return [fetch, $data, $error, $loading, $key];
+	const { clientCtx, fetch, $key, $data, $error, $loading } = /* @__PURE__ */ baseQuery(this, key, params, fn, [/* @__PURE__ */ dedupe(true, false), ...settings]);
+	onStart($data, () => effectScope(() => clientCtx.mounted()));
+	return [
+		fetch,
+		$data,
+		$error,
+		$loading,
+		$key
+	];
 }
-
-// @__NO_SIDE_EFFECTS__
+//#endregion
+//#region src/queries/mutation.ts
+/* @__NO_SIDE_EFFECTS__ */
 function mutation(fn, settings = []) {
-  const clientCtx = forkMutationClient(this, settings);
-  const {
-    mapComputedData,
-    $disabled,
-    loadingDedupe
-  } = clientCtx;
-  const $result = signal(null);
-  const $data = computed(() => mapComputedData($result()));
-  const $error = signal(null);
-  const $loading = signal(false);
-  let prevRequestCtx;
-  const fetch = action((...params) => {
-    if ($disabled?.() === true || loadingDedupe && $loading()) {
-      return Promise.resolve();
-    }
-    const requestCtx = prevRequestCtx = new RequestContext(prevRequestCtx);
-    return clientCtx.run(
-      requestCtx,
-      () => {
-        $loading(true);
-        return fn(...params, requestCtx);
-      },
-      (data, error) => {
-        if (prevRequestCtx === requestCtx) {
-          batch(() => {
-            if (error === null) {
-              $result(data);
-            }
-            $error(error);
-            $loading(false);
-          });
-        }
-      }
-    );
-  });
-  return [
-    fetch,
-    $data,
-    readonly($error),
-    readonly($loading)
-  ];
+	const clientCtx = /* @__PURE__ */ forkMutationClient(this, settings);
+	const { mapComputedData, $disabled, loadingDedupe } = clientCtx;
+	const $result = signal(null);
+	const $data = computed(() => mapComputedData($result()));
+	const $error = signal(null);
+	const $loading = signal(false);
+	let prevRequestCtx;
+	return [
+		action((...params) => {
+			if ($disabled?.() === true || loadingDedupe && $loading()) return Promise.resolve();
+			const requestCtx = prevRequestCtx = new RequestContext(prevRequestCtx);
+			return clientCtx.run(requestCtx, () => {
+				$loading(true);
+				return fn(...params, requestCtx);
+			}, (data, error) => {
+				if (prevRequestCtx === requestCtx) batch(() => {
+					if (error === null) $result(data);
+					$error(error);
+					$loading(false);
+				});
+			});
+		}),
+		$data,
+		readonly($error),
+		readonly($loading)
+	];
 }
-
-// @__NO_SIDE_EFFECTS__
+//#endregion
+//#region src/client.ts
+/**
+* Create a query client with optional settings and extensions.
+* @param settings - The client settings and extensions.
+* @returns The query client.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function client(...settings) {
-  const ctx = new ClientContext();
-  const client2 = {
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-    query: query.bind(ctx),
-    invalidate: ((key) => ctx.invalidate(key)),
-    revalidate: ((key) => ctx.revalidate(key)),
-    $data: dataCacheFacade(ctx),
-    $error: errorCacheFacade(ctx),
-    $loading: loadingCacheFacade(ctx)
-  };
-  for (const setting of settings) {
-    setting(ctx, client2);
-  }
-  return client2;
-}
-// @__NO_SIDE_EFFECTS__
+	const ctx = new ClientContext();
+	const client = {
+		query: query.bind(ctx),
+		invalidate: ((key) => ctx.invalidate(key)),
+		revalidate: ((key) => ctx.revalidate(key)),
+		$data: /* @__PURE__ */ dataCacheFacade(ctx),
+		$error: /* @__PURE__ */ errorCacheFacade(ctx),
+		$loading: /* @__PURE__ */ loadingCacheFacade(ctx)
+	};
+	for (const setting of settings) setting(ctx, client);
+	return client;
+}
+/**
+* Extend client with infinite query capability.
+* @returns The client extension.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function infinites() {
-  return ((ctx, client2) => {
-    client2.infinite = infinite.bind(ctx);
-    return client2;
-  });
+	return ((ctx, client) => {
+		client.infinite = infinite.bind(ctx);
+		return client;
+	});
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Extend client with operation capability.
+* @returns The client extension.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function operations() {
-  return ((ctx, client2) => {
-    client2.operation = operation.bind(ctx);
-    return client2;
-  });
+	return ((ctx, client) => {
+		client.operation = operation.bind(ctx);
+		return client;
+	});
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Extend client with mutation capability.
+* @returns The client extension.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function mutations() {
-  return ((ctx, client2) => {
-    client2.mutation = mutation.bind(ctx);
-    return client2;
-  });
+	return ((ctx, client) => {
+		client.mutation = mutation.bind(ctx);
+		return client;
+	});
 }
+//#endregion
+export { ClientContext, DEFAULT_CACHE_TIME, DEFAULT_DEDUPE_TIME, QueryContext, RequestContext, abort, abortPrevious, abortSignal, abortable, cacheTime, client, codec, decodeEntry, decodeEntryData, decodeEntryDetails, dedupe, dedupeTime, defaultCalcRetryDelay, disabled, encodeEntry, encodeEntryData, encodeEntryDetails, entities, entity, hydratable, indexedDbStorage, infinites, mapError, mutations, onError, onEveryError, onSettled, onSuccess, operationKey, operations, persistence, queryKey, retryOnError, revalidateOn, ssr, stopErrorPropagation, tasks };
 
-export { $networkOnline, $windowVisible, ClientContext, DEFAULT_CACHE_TIME, DEFAULT_DEDUPE_TIME, QueryContext, RequestContext, abort, abortPrevious, abortSignal, abortable, cacheTime, client, dedupe, dedupeTime, defaultCalcRetryDelay, disabled, entities, entity, indexedDbStorage, infinites, mapError, mutations, onError, onEveryError, onSettled, onSuccess, operationKey, operations, queryKey, retryOnError, revalidateOnFocus, revalidateOnInterval, revalidateOnReconnect, stopErrorPropagation, tasks };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map