@nano_kit/query 1.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,951 @@
+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';
+
+const abortControllers = /* @__PURE__ */ new WeakMap();
+// @__NO_SIDE_EFFECTS__
+function abortSignal(ctx) {
+  let controller = abortControllers.get(ctx);
+  if (!controller) {
+    abortControllers.set(ctx, controller = new AbortController());
+  }
+  return controller.signal;
+}
+function abort(promiseOrCtx) {
+  abortControllers.get(promiseOrCtx)?.abort();
+}
+function abortPrevious(ctx) {
+  abort(ctx.prevCtx);
+}
+// @__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;
+  };
+}
+
+// @__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__
+function operationKey(name, filter) {
+  return /* @__PURE__ */ queryKey(name, filter);
+}
+// @__NO_SIDE_EFFECTS__
+function dataCacheFacade(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__
+function loadingCacheFacade(cache) {
+  return (key) => cache.$get(key).loading;
+}
+// @__NO_SIDE_EFFECTS__
+function errorCacheFacade(cache) {
+  return (key) => cache.$get(key).error;
+}
+
+const ENTITY_KEY = "#entity";
+const EntityKey = queryKey(ENTITY_KEY);
+function isIdentifier(value) {
+  const type = typeof value;
+  return type === "number" || type === "string";
+}
+function isEntityRef(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__
+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;
+  };
+}
+
+// @__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__
+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);
+}
+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);
+  }
+}
+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 DEFAULT_DEDUPE_TIME = 4e3;
+const DEFAULT_CACHE_TIME = Infinity;
+const UNSET_REV = Infinity;
+// @__NO_SIDE_EFFECTS__
+function revLock(rev) {
+  return rev > 0 ? rev * -1 : rev;
+}
+// @__NO_SIDE_EFFECTS__
+function revLocked(rev) {
+  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
+    });
+  }
+}
+
+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
+        });
+      }
+    };
+  });
+}
+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);
+    };
+  });
+}
+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();
+  });
+}
+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;
+  };
+}
+
+// @__NO_SIDE_EFFECTS__
+function addFn(prevFn, fn) {
+  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;
+  };
+}
+
+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;
+  };
+}
+
+// @__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
+  );
+}
+function getRetryCount(ctx, key) {
+  return ctx.retryCounts?.get(key.key) || 0;
+}
+function setRetryCount(ctx, key, count) {
+  (ctx.retryCounts ??= /* @__PURE__ */ new Map()).set(key.key, count);
+}
+function clearRetryCount(ctx, key) {
+  ctx.retryCounts?.delete(key.key);
+}
+// @__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;
+  };
+}
+
+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__
+function forkMutationClient(ctx, settings = []) {
+  const child = Object.create(ctx);
+  for (const setting of settings) {
+    setting(child);
+  }
+  return child;
+}
+// @__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__
+function dedupeTime(time) {
+  return (ctx) => ctx.dedupeTime = time;
+}
+// @__NO_SIDE_EFFECTS__
+function cacheTime(time) {
+  return (ctx) => ctx.cacheTime = time;
+}
+// @__NO_SIDE_EFFECTS__
+function mapError(fn) {
+  return (ctx) => ctx.mapError = fn;
+}
+// @__NO_SIDE_EFFECTS__
+function onEveryError(fn) {
+  return (ctx) => ctx.onEveryError = addFn(ctx.onEveryError, fn);
+}
+// @__NO_SIDE_EFFECTS__
+function disabled($disabled) {
+  return (ctx) => ctx.$disabled = $disabled;
+}
+// @__NO_SIDE_EFFECTS__
+function dedupe(loading, time = loading) {
+  return (ctx) => {
+    ctx.loadingDedupe = loading;
+    ctx.timeDedupe = time;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function tasks(runner) {
+  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;
+  }
+}
+function onSuccess(ctx, fn) {
+  ctx.onSuccess = addFn(ctx.onSuccess, fn);
+}
+function onError(ctx, fn) {
+  ctx.onError = addFn(ctx.onError, fn);
+}
+function onSettled(ctx, fn) {
+  ctx.onSettled = addFn(ctx.onSettled, fn);
+}
+function stopErrorPropagation(ctx) {
+  ctx.stopErrorPropagation = true;
+}
+
+// @__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
+  };
+}
+
+// @__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];
+}
+
+// @__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];
+}
+
+// @__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];
+}
+
+// @__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)
+  ];
+}
+
+// @__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__
+function infinites() {
+  return ((ctx, client2) => {
+    client2.infinite = infinite.bind(ctx);
+    return client2;
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function operations() {
+  return ((ctx, client2) => {
+    client2.operation = operation.bind(ctx);
+    return client2;
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function mutations() {
+  return ((ctx, client2) => {
+    client2.mutation = mutation.bind(ctx);
+    return client2;
+  });
+}
+
+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