@echojs-ecosystem/query 0.1.0

package/dist/index.js

@@ -0,0 +1,2140 @@
+import { signal, effect, computed } from '@echojs-ecosystem/reactivity';
+
+// src/provider/context.ts
+var activeProvider = null;
+var getQueryProvider = () => activeProvider;
+var requireQueryProvider = () => {
+  if (!activeProvider) {
+    throw new Error(
+      "Query provider is not installed. Call app.use(createQueryProvider(...)) before using queries."
+    );
+  }
+  return activeProvider;
+};
+var setActiveQueryProvider = (provider) => {
+  activeProvider = provider;
+};
+var resetQueryProvider = () => {
+  activeProvider = null;
+};
+
+// src/client/default-client.ts
+var defaultClient = null;
+var pendingFactory = null;
+var setDefaultQueryClient = (client) => {
+  defaultClient = client;
+};
+var registerDefaultQueryClientFactory = (factory) => {
+  pendingFactory = factory;
+};
+var getDefaultQueryClient = () => {
+  if (!defaultClient) {
+    if (!pendingFactory) {
+      throw new Error(
+        "@echojs-ecosystem/query: no default QueryClient. Call createQueryClient() first or pass { client } to .with()."
+      );
+    }
+    defaultClient = pendingFactory();
+    pendingFactory = null;
+  }
+  return defaultClient;
+};
+
+// src/core/cancelled-error.ts
+var CancelledError = class extends Error {
+  revert;
+  silent;
+  constructor(options) {
+    super("CancelledError");
+    this.name = "CancelledError";
+    this.revert = options?.revert;
+    this.silent = options?.silent;
+  }
+};
+var isCancelledError = (value) => value instanceof CancelledError;
+var isAbortError = (value) => {
+  if (isCancelledError(value)) return true;
+  if (!value || typeof value !== "object") return false;
+  if (value instanceof DOMException && value.name === "AbortError") return true;
+  return value.name === "AbortError";
+};
+
+// src/core/removable.ts
+var Removable = class {
+  gcTimeoutId;
+  gcTimeMs = Number.POSITIVE_INFINITY;
+  scheduleGc(onRemove) {
+    this.clearGcTimeout();
+    if (!Number.isFinite(this.gcTimeMs)) return;
+    this.gcTimeoutId = setTimeout(() => {
+      onRemove();
+    }, this.gcTimeMs);
+  }
+  clearGcTimeout() {
+    if (this.gcTimeoutId !== void 0) {
+      clearTimeout(this.gcTimeoutId);
+      this.gcTimeoutId = void 0;
+    }
+  }
+  updateGcTime(cacheTimeMs) {
+    this.gcTimeMs = cacheTimeMs;
+  }
+};
+
+// src/utils/sleep.ts
+var sleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+
+// src/core/retryer.ts
+var defaultRetryDelay = (failureCount) => Math.min(1e3 * 2 ** failureCount, 3e4);
+var shouldRetry = (failureCount, error, retry) => {
+  if (retry === false || retry === void 0) return false;
+  if (typeof retry === "number") return failureCount < retry;
+  if (retry === true) return true;
+  return retry(failureCount, error);
+};
+var getRetryDelay = (failureCount, error, retryDelay) => {
+  if (typeof retryDelay === "function") return retryDelay(failureCount, error);
+  if (typeof retryDelay === "number") return retryDelay;
+  return defaultRetryDelay(failureCount);
+};
+var createRetryer = (config) => {
+  let failureCount = 0;
+  let rejectFn;
+  let resolveFn;
+  let settled = false;
+  const promise = new Promise((resolve, reject) => {
+    resolveFn = resolve;
+    rejectFn = reject;
+  });
+  const cancel = (options) => {
+    if (settled) return;
+    const error = new CancelledError({ silent: options?.silent });
+    config.onCancel?.(error);
+    settled = true;
+    rejectFn(error);
+  };
+  const run = () => {
+    if (settled) return;
+    const initialPromise = failureCount === 0 ? config.initialPromise : void 0;
+    Promise.resolve(initialPromise ?? config.fn()).then((value) => {
+      if (settled) return;
+      settled = true;
+      resolveFn(value);
+    }).catch(async (error) => {
+      if (settled) return;
+      if (isCancelledError(error) || isAbortError(error)) {
+        settled = true;
+        rejectFn(error);
+        return;
+      }
+      if (shouldRetry(failureCount, error, config.retry)) {
+        failureCount += 1;
+        config.onFail?.(failureCount, error);
+        await sleep(getRetryDelay(failureCount, error, config.retryDelay));
+        if (!settled) run();
+        return;
+      }
+      settled = true;
+      rejectFn(error);
+    });
+  };
+  return {
+    promise,
+    cancel,
+    start: () => {
+      run();
+      return promise;
+    }
+  };
+};
+
+// src/core/query-state.ts
+var defaultQueryState = () => ({
+  data: void 0,
+  error: null,
+  status: "idle",
+  fetchStatus: "idle",
+  dataUpdatedAt: 0,
+  errorUpdatedAt: 0,
+  fetchFailureCount: 0,
+  isInvalidated: false,
+  hadSuccess: false
+});
+var queryReducer = (state, action) => {
+  switch (action.type) {
+    case "fetch":
+      return {
+        ...state,
+        fetchStatus: "fetching",
+        ...state.data === void 0 && state.status === "idle" ? { status: "pending", error: null } : {}
+      };
+    case "success":
+      return {
+        ...state,
+        data: action.data,
+        error: null,
+        status: "success",
+        fetchStatus: "idle",
+        dataUpdatedAt: Date.now(),
+        fetchFailureCount: 0,
+        isInvalidated: false,
+        hadSuccess: true
+      };
+    case "error":
+      return {
+        ...state,
+        error: action.error,
+        status: "error",
+        fetchStatus: "idle",
+        errorUpdatedAt: Date.now(),
+        fetchFailureCount: state.fetchFailureCount + 1,
+        isInvalidated: true
+      };
+    case "failed":
+      return {
+        ...state,
+        fetchFailureCount: action.failureCount,
+        error: action.error
+      };
+    case "invalidate":
+      return {
+        ...state,
+        isInvalidated: true
+      };
+    case "setState":
+      return {
+        ...state,
+        ...action.state
+      };
+    default:
+      return state;
+  }
+};
+var timeUntilStale = (updatedAt, staleTimeMs = 0) => Math.max(updatedAt + staleTimeMs - Date.now(), 0);
+var isStaleByTime = (dataUpdatedAt, staleTimeMs, isInvalidated, hasData) => {
+  if (!hasData) return true;
+  if (isInvalidated) return true;
+  if (!Number.isFinite(staleTimeMs)) return false;
+  return timeUntilStale(dataUpdatedAt, staleTimeMs) === 0;
+};
+
+// src/async/lifecycle.ts
+var runLifecycle = async (hooks, phase, ctx) => {
+  if (phase === "start") hooks.onStart?.(ctx);
+  if (phase === "success") hooks.onSuccess?.(ctx);
+  if (phase === "error") hooks.onError?.(ctx);
+  if (phase === "settled") hooks.onSettled?.(ctx);
+};
+
+// src/async/abort-control.ts
+var resolveAbortInput = (input) => {
+  if (!input) return void 0;
+  if (typeof input === "function") return input();
+  return input;
+};
+var abortWithReason = (controller, reason) => {
+  if (!controller || controller.signal.aborted) return;
+  try {
+    controller.abort(reason);
+  } catch {
+    controller.abort();
+  }
+};
+var linkSignal = (source, target) => {
+  if (source.aborted) {
+    abortWithReason(target, source.reason);
+    return () => {
+    };
+  }
+  const listener = () => abortWithReason(target, source.reason);
+  source.addEventListener("abort", listener, { once: true });
+  return () => source.removeEventListener("abort", listener);
+};
+var mergeFetchAbortSource = (...sources) => {
+  let abortController;
+  let signal8;
+  for (const source of sources) {
+    if (!source) continue;
+    if (source.abortController !== void 0) abortController = source.abortController;
+    if (source.signal !== void 0) signal8 = source.signal;
+  }
+  return { abortController, signal: signal8 };
+};
+var createFetchAbortHandle = (source) => {
+  const controllerInput = resolveAbortInput(source?.abortController);
+  const signalInput = resolveAbortInput(source?.signal);
+  const unlinks = [];
+  let controller;
+  let ownsController;
+  if (controllerInput instanceof AbortController) {
+    controller = controllerInput;
+    ownsController = false;
+  } else if (controllerInput instanceof AbortSignal) {
+    controller = new AbortController();
+    ownsController = true;
+    unlinks.push(linkSignal(controllerInput, controller));
+  } else {
+    controller = new AbortController();
+    ownsController = true;
+  }
+  if (signalInput) {
+    const external = signalInput instanceof AbortSignal ? signalInput : signalInput.signal;
+    if (external !== controller.signal) {
+      unlinks.push(linkSignal(external, controller));
+    }
+  }
+  return {
+    controller,
+    signal: controller.signal,
+    ownsController,
+    abort: (reason) => abortWithReason(controller, reason),
+    dispose: () => {
+      for (const unlink of unlinks) unlink();
+    }
+  };
+};
+
+// src/utils/hash.ts
+var hasObjectPrototype = (value) => Object.prototype.toString.call(value) === "[object Object]";
+var isPlainObject = (value) => {
+  if (!hasObjectPrototype(value)) return false;
+  const record = value;
+  const ctor = record.constructor;
+  if (ctor === void 0) return true;
+  const prot = ctor.prototype;
+  if (!hasObjectPrototype(prot)) return false;
+  if (!Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf")) return false;
+  if (Object.getPrototypeOf(value) !== Object.prototype) return false;
+  return true;
+};
+var hashKey = (queryKey) => JSON.stringify(
+  queryKey,
+  (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+    result[key] = val[key];
+    return result;
+  }, {}) : val
+);
+var partialMatchKey = (a, b) => {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    const bRecord = b;
+    const aRecord = a;
+    return Object.keys(bRecord).every(
+      (key) => partialMatchKey(aRecord[key], bRecord[key])
+    );
+  }
+  return false;
+};
+
+// src/utils/functional-update.ts
+var functionalUpdate = (updater, input) => typeof updater === "function" ? updater(input) : updater;
+
+// src/core/query.ts
+var Query = class extends Removable {
+  queryKey;
+  queryHash;
+  definition;
+  client;
+  params;
+  options;
+  state;
+  observers = /* @__PURE__ */ new Set();
+  $data;
+  $error;
+  $status;
+  $fetchStatus;
+  $pendingCount;
+  $updatedAt;
+  $isInvalidated;
+  #retryer;
+  #abortController;
+  #abortDispose;
+  #cache;
+  constructor(config) {
+    super();
+    this.client = config.client;
+    this.#cache = config.cache;
+    this.definition = config.definition;
+    this.params = config.params;
+    this.queryKey = config.queryKey;
+    this.queryHash = hashKey(config.queryKey);
+    this.options = config.options;
+    this.state = defaultQueryState();
+    this.updateGcTime(this.options.cacheTimeMs);
+    this.$data = signal(void 0);
+    this.$error = signal(null);
+    this.$status = signal("idle");
+    this.$fetchStatus = signal("idle");
+    this.$pendingCount = signal(0);
+    this.$updatedAt = signal(null);
+    this.$isInvalidated = signal(false);
+  }
+  get promise() {
+    return this.#retryer?.promise;
+  }
+  isActive() {
+    return this.observers.size > 0;
+  }
+  isStale() {
+    return isStaleByTime(
+      this.state.dataUpdatedAt,
+      this.options.staleTimeMs,
+      this.state.isInvalidated,
+      this.state.data !== void 0
+    );
+  }
+  isStaleByTime(staleTimeMs = this.options.staleTimeMs) {
+    return isStaleByTime(
+      this.state.dataUpdatedAt,
+      staleTimeMs,
+      this.state.isInvalidated,
+      this.state.data !== void 0
+    );
+  }
+  hasData() {
+    return this.state.data !== void 0;
+  }
+  addObserver(observer) {
+    if (!this.observers.has(observer)) {
+      this.observers.add(observer);
+      this.clearGcTimeout();
+    }
+  }
+  removeObserver(observer) {
+    if (this.observers.delete(observer) && this.observers.size === 0) {
+      this.scheduleGc(() => this.#cache.remove(this));
+    }
+  }
+  setData(updater) {
+    const next = functionalUpdate(updater, this.state.data);
+    this.#dispatch({ type: "success", data: next });
+    return next;
+  }
+  invalidate() {
+    if (!this.state.isInvalidated) {
+      this.#dispatch({ type: "invalidate" });
+      this.#cache.emit({
+        type: "queryInvalidated",
+        queryKey: this.queryKey,
+        hash: this.queryHash
+      });
+    }
+  }
+  getAbortController() {
+    return this.#abortController;
+  }
+  getAbortSignal() {
+    return this.#abortController?.signal;
+  }
+  cancel(options) {
+    abortWithReason(this.#abortController, options?.reason);
+    const promise = this.#retryer?.promise;
+    if (promise) {
+      void promise.catch(() => void 0);
+    }
+    this.#retryer?.cancel(options);
+    this.#retryer = void 0;
+    this.#clearAbortHandle();
+    this.#dispatch({ type: "setState", state: { fetchStatus: "idle" } });
+    return promise ? promise.then(() => void 0).catch(() => void 0) : Promise.resolve();
+  }
+  async fetch(options) {
+    if (this.state.fetchStatus !== "idle" && this.#retryer) {
+      if (options?.cancelRefetch) {
+        await this.cancel({ silent: true });
+      } else {
+        return this.#retryer.promise;
+      }
+    }
+    const abortHandle = createFetchAbortHandle(
+      mergeFetchAbortSource(this.options, options)
+    );
+    this.#abortController = abortHandle.controller;
+    this.#abortDispose = abortHandle.dispose;
+    const { controller: abortController, signal: signal8 } = abortHandle;
+    const lifecycleCtx = {
+      params: this.params,
+      queryKey: this.queryKey,
+      queryClient: this.client
+    };
+    this.#dispatch({ type: "fetch" });
+    this.$pendingCount.set(this.$pendingCount.peek() + 1);
+    void runLifecycle(this.options, "start", lifecycleCtx);
+    this.#retryer = createRetryer({
+      fn: async () => {
+        const raw = await this.definition.options.queryFn({
+          params: this.params,
+          signal: signal8,
+          abortController,
+          queryClient: this.client,
+          queryKey: this.queryKey
+        });
+        if (signal8.aborted) {
+          throw new CancelledError({ silent: true });
+        }
+        const transform = this.definition.options.transform;
+        return transform ? await transform(raw) : raw;
+      },
+      onCancel: () => abortHandle.abort(),
+      onFail: (failureCount, error) => {
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.#dispatch({
+          type: "failed",
+          failureCount,
+          error: err
+        });
+      },
+      retry: this.options.retry,
+      retryDelay: this.options.retryDelay
+    });
+    try {
+      const data = await this.#retryer.start();
+      this.#dispatch({ type: "success", data });
+      this.#cache.emit({
+        type: "queryFetched",
+        queryKey: this.queryKey,
+        hash: this.queryHash,
+        data
+      });
+      await runLifecycle(this.options, "success", { ...lifecycleCtx, data });
+      await runLifecycle(this.options, "settled", { ...lifecycleCtx, data });
+      return data;
+    } catch (error) {
+      if (isCancelledError(error)) {
+        if (error.silent) {
+          return this.state.data;
+        }
+        throw error;
+      }
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.#dispatch({ type: "error", error: err });
+      await runLifecycle(this.options, "error", { ...lifecycleCtx, error: err });
+      await runLifecycle(this.options, "settled", { ...lifecycleCtx, error: err });
+      throw error;
+    } finally {
+      this.$pendingCount.set(Math.max(0, this.$pendingCount.peek() - 1));
+      this.#retryer = void 0;
+      this.#clearAbortHandle();
+      this.scheduleGc(() => {
+        if (this.observers.size === 0) this.#cache.remove(this);
+      });
+    }
+  }
+  #clearAbortHandle() {
+    this.#abortDispose?.();
+    this.#abortDispose = void 0;
+    this.#abortController = void 0;
+  }
+  onFocus() {
+    if (this.isActive() && this.isStale() && this.options.refetchOnWindowFocus) {
+      void this.fetch();
+    }
+  }
+  onOnline() {
+    if (this.isActive() && this.isStale() && this.options.refetchOnReconnect) {
+      void this.fetch();
+    }
+  }
+  #dispatch(action) {
+    this.state = queryReducer(this.state, action);
+    this.syncSignals();
+    this.#cache.emit({
+      type: "queryUpdated",
+      queryKey: this.queryKey,
+      hash: this.queryHash
+    });
+    for (const observer of this.observers) {
+      observer.onQueryUpdate();
+    }
+  }
+  syncSignals() {
+    this.$data.set(this.state.data);
+    this.$error.set(this.state.error);
+    this.$status.set(this.state.status);
+    this.$fetchStatus.set(this.state.fetchStatus);
+    this.$updatedAt.set(this.state.dataUpdatedAt || null);
+    this.$isInvalidated.set(this.state.isInvalidated);
+  }
+};
+
+// src/query/query-options.ts
+var DEFAULT_CACHE_TIME_MS = 5 * 6e4;
+var defaultQueryOptions = (config) => ({
+  staleTime: config?.defaultOptions?.queries?.staleTime ?? 0,
+  cacheTime: config?.defaultOptions?.queries?.cacheTime ?? DEFAULT_CACHE_TIME_MS,
+  retry: config?.defaultOptions?.queries?.retry ?? false,
+  retryDelay: config?.defaultOptions?.queries?.retryDelay ?? 1e3,
+  keepPreviousData: config?.defaultOptions?.queries?.keepPreviousData ?? false,
+  abortPrevious: config?.defaultOptions?.queries?.abortPrevious ?? true
+});
+var mergeQueryDefinitionOptions = (options, config, provider) => ({
+  ...defaultQueryOptions(config),
+  ...provider?.config.defaultOptions?.queries,
+  ...options
+});
+var toMs = (value, fallback) => {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value)) return Number.POSITIVE_INFINITY;
+  return value;
+};
+
+// src/query/query-status.ts
+var DEFAULT_CACHE_TIME_MS2 = 5 * 6e4;
+var resolveQueryOptions = (options) => {
+  const staleTime = options.staleTime ?? 0;
+  const cacheTime = options.cacheTime ?? DEFAULT_CACHE_TIME_MS2;
+  return {
+    ...options,
+    staleTime,
+    cacheTime,
+    retry: options.retry ?? false,
+    retryDelay: options.retryDelay ?? 1e3,
+    keepPreviousData: options.keepPreviousData ?? false,
+    abortPrevious: options.abortPrevious ?? true,
+    staleTimeMs: toMs(staleTime, 0),
+    cacheTimeMs: toMs(cacheTime, DEFAULT_CACHE_TIME_MS2)
+  };
+};
+var resolveInstanceOptions = (definitionOptions, instanceOptions) => {
+  const staleTime = instanceOptions?.staleTime ?? definitionOptions.staleTime ?? 0;
+  const cacheTime = instanceOptions?.cacheTime ?? definitionOptions.cacheTime ?? DEFAULT_CACHE_TIME_MS2;
+  return {
+    ...definitionOptions,
+    ...instanceOptions,
+    staleTime,
+    cacheTime,
+    staleTimeMs: toMs(staleTime, 0),
+    cacheTimeMs: toMs(cacheTime, DEFAULT_CACHE_TIME_MS2),
+    enabled: instanceOptions?.enabled ?? true,
+    refetchOnMount: instanceOptions?.refetchOnMount ?? true,
+    refetchOnWindowFocus: instanceOptions?.refetchOnWindowFocus ?? true,
+    refetchOnReconnect: instanceOptions?.refetchOnReconnect ?? true,
+    keepPreviousData: instanceOptions?.keepPreviousData ?? definitionOptions.keepPreviousData ?? false,
+    abortPrevious: instanceOptions?.abortPrevious ?? definitionOptions.abortPrevious ?? true,
+    retry: instanceOptions?.retry ?? definitionOptions.retry ?? false,
+    retryDelay: instanceOptions?.retryDelay ?? definitionOptions.retryDelay ?? 1e3,
+    onStart: instanceOptions?.onStart ?? definitionOptions.onStart,
+    onSuccess: instanceOptions?.onSuccess ?? definitionOptions.onSuccess,
+    onError: instanceOptions?.onError ?? definitionOptions.onError,
+    onSettled: instanceOptions?.onSettled ?? definitionOptions.onSettled
+  };
+};
+var isEnabled = (enabled) => typeof enabled === "function" ? enabled() : enabled;
+var isQueryPending = (status) => status === "pending";
+var isQueryFetching = (fetchStatus) => fetchStatus === "fetching";
+var isQuerySuccess = (status) => status === "success";
+var isQueryError = (status) => status === "error";
+var isQueryIdle = (status) => status === "idle";
+var isQueryPaused = (fetchStatus) => fetchStatus === "paused";
+var resolveDefinitionOptions = (definition) => resolveQueryOptions(definition.options);
+
+// src/query/query-observer.ts
+var QueryObserver = class {
+  definition;
+  client;
+  options;
+  #query = null;
+  #previousQuery = null;
+  #params;
+  #disposeParams = null;
+  #destroyed = false;
+  #listeners = /* @__PURE__ */ new Set();
+  #currentHash = null;
+  constructor(definition, client, params, instanceOptions) {
+    this.definition = definition;
+    this.client = client;
+    this.options = resolveInstanceOptions(
+      resolveDefinitionOptions(definition),
+      instanceOptions
+    );
+    if (typeof params === "function") {
+      this.#disposeParams = effect(() => {
+        this.setParams(params());
+      });
+    } else {
+      this.setParams(params);
+    }
+  }
+  getQuery() {
+    return this.#query;
+  }
+  getPreviousQuery() {
+    return this.#previousQuery;
+  }
+  getParams() {
+    return this.#params;
+  }
+  onQueryUpdate() {
+    for (const listener of this.#listeners) listener();
+  }
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  setParams(params) {
+    if (this.#destroyed) return;
+    this.#params = params;
+    const queryKey = this.definition.queryKey(params);
+    const hash = hashKey(queryKey);
+    if (this.#currentHash === hash) {
+      void this.maybeFetch(false);
+      return;
+    }
+    if (this.#query) {
+      if (this.options.abortPrevious) {
+        void this.#query.cancel({ silent: true });
+      }
+      this.#detach(this.#query);
+      this.#previousQuery = this.options.keepPreviousData ? this.#query : null;
+    }
+    this.#currentHash = hash;
+    this.#query = this.client.queryCache.build({
+      client: this.client,
+      cache: this.client.queryCache,
+      definition: this.definition,
+      params,
+      queryKey,
+      options: this.options
+    });
+    this.#query.addObserver(this);
+    void this.maybeFetch(true);
+    this.onQueryUpdate();
+  }
+  maybeFetch(paramsChanged) {
+    if (!this.#query || !isEnabled(this.options.enabled)) return;
+    const stale = this.#query.isStale();
+    const hasData = this.#query.hasData();
+    if (!hasData || stale) {
+      void this.fetch();
+      return;
+    }
+    if (paramsChanged && this.options.refetchOnMount === true) {
+      void this.fetch();
+    }
+  }
+  async fetch(options) {
+    if (!this.#query) throw new Error("QueryObserver has no active query");
+    try {
+      return await this.#query.fetch(options);
+    } catch (error) {
+      if (isCancelledError(error) && !options?.throwOnError) {
+        throw error;
+      }
+      if (options?.throwOnError) throw error;
+      throw error;
+    }
+  }
+  async refetch(options) {
+    return this.fetch(options);
+  }
+  invalidate() {
+    this.#query?.invalidate();
+    if (this.#query?.isActive()) {
+      void this.fetch();
+    }
+  }
+  cancel(options) {
+    return this.#query?.cancel(options) ?? Promise.resolve();
+  }
+  remove() {
+    if (!this.#query) return;
+    this.#detach(this.#query);
+    this.client.queryCache.remove(this.#query);
+    this.#query = null;
+    this.#currentHash = null;
+    this.onQueryUpdate();
+  }
+  destroy() {
+    if (this.#destroyed) return;
+    this.#destroyed = true;
+    this.#disposeParams?.();
+    if (this.#query) this.#detach(this.#query);
+    this.#listeners.clear();
+  }
+  #detach(query) {
+    query.removeObserver(this);
+  }
+};
+
+// src/query/query-instance.ts
+var effectiveQuery = (observer) => {
+  const query = observer.getQuery();
+  if (!query) return observer.getPreviousQuery();
+  if (query.hasData()) return query;
+  const prev = observer.getPreviousQuery();
+  if (prev && observer.options.keepPreviousData) return prev;
+  return query;
+};
+var createQueryInstance = (definition, client, params, instanceOptions) => {
+  const observer = new QueryObserver(definition, client, params, instanceOptions);
+  const $params = signal(observer.getParams());
+  observer.subscribe(() => $params.set(observer.getParams()));
+  const readQuery = () => effectiveQuery(observer);
+  const $data = computed(() => readQuery()?.$data.value());
+  const $error = computed(() => readQuery()?.$error.value() ?? null);
+  const $status = computed(() => readQuery()?.$status.value() ?? "idle");
+  const $fetchStatus = computed(() => observer.getQuery()?.$fetchStatus.value() ?? "idle");
+  const $pendingCount = computed(() => observer.getQuery()?.$pendingCount.value() ?? 0);
+  const $updatedAt = computed(() => observer.getQuery()?.$updatedAt.value() ?? null);
+  const $isStale = computed(() => observer.getQuery()?.isStale() ?? true);
+  const $abortSignal = computed(() => readQuery()?.getAbortSignal() ?? null);
+  return {
+    kind: "query-instance",
+    value: () => $data.value(),
+    data: () => $data.value(),
+    error: () => $error.value(),
+    params: () => $params.value(),
+    status: () => $status.value(),
+    fetchStatus: () => $fetchStatus.value(),
+    pending: () => isQueryPending($status.value()),
+    isPending: () => isQueryPending($status.value()),
+    isFirstPending: () => {
+      const q = observer.getQuery();
+      return q ? q.state.status === "pending" && !q.state.hadSuccess : false;
+    },
+    isRefetching: () => {
+      const q = observer.getQuery();
+      return q ? q.state.fetchStatus === "fetching" && q.hasData() : false;
+    },
+    isFetching: () => isQueryFetching($fetchStatus.value()),
+    isSuccess: () => isQuerySuccess($status.value()),
+    isError: () => isQueryError($status.value()),
+    isIdle: () => isQueryIdle($status.value()),
+    isStale: () => $isStale.value(),
+    isPaused: () => isQueryPaused($fetchStatus.value()),
+    hasData: () => $data.value() !== void 0,
+    hasError: () => $error.value() !== null,
+    refetch: (options) => observer.refetch(options),
+    invalidate: () => observer.invalidate(),
+    cancel: (options) => observer.cancel(options),
+    abort: (reason) => observer.cancel({ reason }),
+    abortController: () => observer.getQuery()?.getAbortController() ?? null,
+    abortSignal: () => observer.getQuery()?.getAbortSignal() ?? null,
+    remove: () => {
+      observer.remove();
+      observer.destroy();
+    },
+    subscribe(listener) {
+      return observer.subscribe(() => listener($data.value()));
+    },
+    $data,
+    $error,
+    $params,
+    $status,
+    $fetchStatus,
+    $pendingCount,
+    $isStale,
+    $updatedAt,
+    $abortSignal
+  };
+};
+
+// src/query/create-query.ts
+var createQuery = (options, meta) => {
+  const provider = meta?.provider ?? getQueryProvider();
+  const mergedOptions = mergeQueryDefinitionOptions(
+    options,
+    provider?.config,
+    provider
+  );
+  resolveQueryOptions(mergedOptions);
+  const definition = {
+    kind: "query-definition",
+    name: options.name,
+    options: mergedOptions,
+    queryKey(params) {
+      return mergedOptions.queryKey(params);
+    },
+    with(params, instanceOptions) {
+      const client = instanceOptions?.client ?? provider?.client ?? getDefaultQueryClient();
+      return createQueryInstance(definition, client, params, instanceOptions);
+    },
+    withStore(store, map, instanceOptions) {
+      const client = instanceOptions?.client ?? provider?.client ?? getDefaultQueryClient();
+      return createQueryInstance(
+        definition,
+        client,
+        () => map(store.value()),
+        instanceOptions
+      );
+    }
+  };
+  return definition;
+};
+
+// src/core/infinite-query-state.ts
+var defaultInfiniteQueryState = () => ({
+  data: void 0,
+  error: null,
+  status: "idle",
+  fetchStatus: "idle",
+  dataUpdatedAt: 0,
+  errorUpdatedAt: 0,
+  fetchFailureCount: 0,
+  isInvalidated: false,
+  hadSuccess: false,
+  fetchingNextPage: false,
+  fetchingPreviousPage: false
+});
+var infiniteQueryReducer = (state, action) => {
+  switch (action.type) {
+    case "fetch":
+      return {
+        ...state,
+        fetchStatus: "fetching",
+        fetchingNextPage: action.direction === "next" || action.direction === "initial",
+        fetchingPreviousPage: action.direction === "previous",
+        ...state.data === void 0 && state.status === "idle" ? { status: "pending", error: null } : {}
+      };
+    case "success":
+      return {
+        ...state,
+        data: action.data,
+        error: null,
+        status: "success",
+        fetchStatus: "idle",
+        dataUpdatedAt: Date.now(),
+        fetchFailureCount: 0,
+        isInvalidated: false,
+        hadSuccess: true,
+        fetchingNextPage: false,
+        fetchingPreviousPage: false
+      };
+    case "error":
+      return {
+        ...state,
+        error: action.error,
+        status: "error",
+        fetchStatus: "idle",
+        errorUpdatedAt: Date.now(),
+        fetchFailureCount: state.fetchFailureCount + 1,
+        isInvalidated: true,
+        fetchingNextPage: false,
+        fetchingPreviousPage: false
+      };
+    case "failed":
+      return {
+        ...state,
+        fetchFailureCount: action.failureCount,
+        error: action.error
+      };
+    case "invalidate":
+      return { ...state, isInvalidated: true };
+    case "reset":
+      return defaultInfiniteQueryState();
+    case "setState":
+      return { ...state, ...action.state };
+    default:
+      return state;
+  }
+};
+
+// src/core/infinite-query.ts
+var hasInfiniteNextPage = (data, getNextPageParam) => {
+  if (!data || data.pages.length === 0) return true;
+  const lastPage = data.pages[data.pages.length - 1];
+  const next = getNextPageParam(lastPage, data.pages);
+  return next !== void 0 && next !== null;
+};
+var hasInfinitePreviousPage = (data, getPreviousPageParam) => {
+  if (!getPreviousPageParam || !data || data.pages.length === 0) return false;
+  const firstPage = data.pages[0];
+  const prev = getPreviousPageParam(firstPage, data.pages);
+  return prev !== void 0 && prev !== null;
+};
+var InfiniteQuery = class extends Removable {
+  queryKey;
+  queryHash;
+  definition;
+  client;
+  params;
+  options;
+  state;
+  observers = /* @__PURE__ */ new Set();
+  $data;
+  $error;
+  $status;
+  $fetchStatus;
+  $pendingCount;
+  $updatedAt;
+  $isInvalidated;
+  $fetchingNextPage;
+  $fetchingPreviousPage;
+  #retryer;
+  #abortController;
+  #abortDispose;
+  #cache;
+  #requestId = 0;
+  constructor(config) {
+    super();
+    this.client = config.client;
+    this.#cache = config.cache;
+    this.definition = config.definition;
+    this.params = config.params;
+    this.queryKey = config.queryKey;
+    this.queryHash = hashKey(config.queryKey);
+    this.options = config.options;
+    this.state = defaultInfiniteQueryState();
+    this.updateGcTime(this.options.cacheTimeMs);
+    this.$data = signal(void 0);
+    this.$error = signal(null);
+    this.$status = signal("idle");
+    this.$fetchStatus = signal("idle");
+    this.$pendingCount = signal(0);
+    this.$updatedAt = signal(null);
+    this.$isInvalidated = signal(false);
+    this.$fetchingNextPage = signal(false);
+    this.$fetchingPreviousPage = signal(false);
+  }
+  isActive() {
+    return this.observers.size > 0;
+  }
+  isStale() {
+    return isStaleByTime(
+      this.state.dataUpdatedAt,
+      this.options.staleTimeMs,
+      this.state.isInvalidated,
+      this.state.data !== void 0
+    );
+  }
+  hasData() {
+    return this.state.data !== void 0 && this.state.data.pages.length > 0;
+  }
+  hasNextPage() {
+    return hasInfiniteNextPage(this.state.data, this.definition.options.getNextPageParam);
+  }
+  hasPreviousPage() {
+    return hasInfinitePreviousPage(this.state.data, this.definition.options.getPreviousPageParam);
+  }
+  addObserver(observer) {
+    if (!this.observers.has(observer)) {
+      this.observers.add(observer);
+      this.clearGcTimeout();
+    }
+  }
+  removeObserver(observer) {
+    if (this.observers.delete(observer) && this.observers.size === 0) {
+      this.scheduleGc(() => this.#cache.remove(this));
+    }
+  }
+  reset() {
+    this.#requestId += 1;
+    void this.cancel({ silent: true });
+    this.#dispatch({ type: "reset" });
+  }
+  getAbortController() {
+    return this.#abortController;
+  }
+  getAbortSignal() {
+    return this.#abortController?.signal;
+  }
+  cancel(options) {
+    this.#requestId += 1;
+    abortWithReason(this.#abortController, options?.reason);
+    const promise = this.#retryer?.promise;
+    this.#retryer?.cancel(options);
+    this.#retryer = void 0;
+    this.#clearAbortHandle();
+    this.#dispatch({
+      type: "setState",
+      state: {
+        fetchStatus: "idle",
+        fetchingNextPage: false,
+        fetchingPreviousPage: false
+      }
+    });
+    return promise ? promise.then(() => void 0).catch(() => void 0) : Promise.resolve();
+  }
+  async refetch(options) {
+    await this.cancel({ silent: true });
+    this.#dispatch({ type: "reset" });
+    await this.fetchPage("initial", options);
+    if (!this.state.data) {
+      throw new Error("Infinite query refetch failed");
+    }
+    return this.state.data;
+  }
+  async fetchNextPage(options) {
+    if (!this.hasNextPage()) return null;
+    const direction = this.hasData() ? "next" : "initial";
+    return this.fetchPage(direction, options);
+  }
+  async fetchPreviousPage(options) {
+    if (!this.hasPreviousPage()) return null;
+    return this.fetchPage("previous", options);
+  }
+  async fetchPage(direction, abortSource) {
+    if (direction === "next" && !this.hasNextPage()) return null;
+    if (direction === "previous" && !this.hasPreviousPage()) return null;
+    const requestId = ++this.#requestId;
+    const abortHandle = createFetchAbortHandle(
+      mergeFetchAbortSource(this.options, abortSource)
+    );
+    this.#abortController = abortHandle.controller;
+    this.#abortDispose = abortHandle.dispose;
+    const { controller: abortController, signal: signal8 } = abortHandle;
+    const { initialPageParam, getNextPageParam, getPreviousPageParam } = this.definition.options;
+    const current = this.state.data;
+    let pageParam;
+    if (direction === "initial") {
+      pageParam = initialPageParam;
+    } else if (direction === "next") {
+      const lastPage = current.pages[current.pages.length - 1];
+      pageParam = getNextPageParam(lastPage, current.pages);
+    } else {
+      const firstPage = current.pages[0];
+      pageParam = getPreviousPageParam(firstPage, current.pages);
+    }
+    const lifecycleCtx = {
+      params: this.params,
+      queryKey: this.queryKey,
+      queryClient: this.client
+    };
+    this.#dispatch({ type: "fetch", direction });
+    this.$pendingCount.set(this.$pendingCount.peek() + 1);
+    void runLifecycle(this.options, "start", lifecycleCtx);
+    this.#retryer = createRetryer({
+      fn: async () => {
+        const page = await this.definition.options.queryFn({
+          params: this.params,
+          pageParam,
+          signal: signal8,
+          abortController,
+          queryClient: this.client,
+          queryKey: this.queryKey
+        });
+        if (signal8.aborted) {
+          throw new CancelledError({ silent: true });
+        }
+        return page;
+      },
+      onCancel: () => abortHandle.abort(),
+      onFail: (failureCount, error) => {
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.#dispatch({ type: "failed", failureCount, error: err });
+      },
+      retry: this.options.retry,
+      retryDelay: this.options.retryDelay
+    });
+    try {
+      const page = await this.#retryer.start();
+      if (requestId !== this.#requestId) {
+        return null;
+      }
+      const nextData = this.#mergePage(direction, pageParam, page);
+      this.#dispatch({ type: "success", data: nextData });
+      this.#cache.emit({
+        type: "infiniteQueryFetched",
+        queryKey: this.queryKey,
+        hash: this.queryHash
+      });
+      await runLifecycle(this.options, "success", { ...lifecycleCtx, data: nextData });
+      await runLifecycle(this.options, "settled", { ...lifecycleCtx, data: nextData });
+      return page;
+    } catch (error) {
+      if (requestId !== this.#requestId) {
+        return null;
+      }
+      if (isCancelledError(error)) {
+        if (error.silent) {
+          return null;
+        }
+        throw error;
+      }
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.#dispatch({ type: "error", error: err });
+      await runLifecycle(this.options, "error", { ...lifecycleCtx, error: err });
+      await runLifecycle(this.options, "settled", { ...lifecycleCtx, error: err });
+      throw error;
+    } finally {
+      if (requestId === this.#requestId) {
+        this.$pendingCount.set(Math.max(0, this.$pendingCount.peek() - 1));
+        this.#retryer = void 0;
+        this.#clearAbortHandle();
+        this.scheduleGc(() => {
+          if (this.observers.size === 0) this.#cache.remove(this);
+        });
+      }
+    }
+  }
+  #clearAbortHandle() {
+    this.#abortDispose?.();
+    this.#abortDispose = void 0;
+    this.#abortController = void 0;
+  }
+  onFocus() {
+    if (this.isActive() && this.isStale() && this.options.refetchOnWindowFocus) {
+      void this.refetch();
+    }
+  }
+  onOnline() {
+    if (this.isActive() && this.isStale() && this.options.refetchOnReconnect) {
+      void this.refetch();
+    }
+  }
+  #mergePage(direction, pageParam, page) {
+    const current = this.state.data;
+    if (direction === "initial" || !current) {
+      return { pages: [page], pageParams: [pageParam] };
+    }
+    if (direction === "next") {
+      return {
+        pages: [...current.pages, page],
+        pageParams: [...current.pageParams, pageParam]
+      };
+    }
+    return {
+      pages: [page, ...current.pages],
+      pageParams: [pageParam, ...current.pageParams]
+    };
+  }
+  #dispatch(action) {
+    this.state = infiniteQueryReducer(this.state, action);
+    this.syncSignals();
+    this.#cache.emit({
+      type: "infiniteQueryUpdated",
+      queryKey: this.queryKey,
+      hash: this.queryHash
+    });
+    for (const observer of this.observers) {
+      observer.onInfiniteQueryUpdate();
+    }
+  }
+  syncSignals() {
+    this.$data.set(this.state.data);
+    this.$error.set(this.state.error);
+    this.$status.set(this.state.status);
+    this.$fetchStatus.set(this.state.fetchStatus);
+    this.$updatedAt.set(this.state.dataUpdatedAt || null);
+    this.$isInvalidated.set(this.state.isInvalidated);
+    this.$fetchingNextPage.set(this.state.fetchingNextPage);
+    this.$fetchingPreviousPage.set(this.state.fetchingPreviousPage);
+  }
+};
+
+// src/query/infinite-query-status.ts
+var DEFAULT_CACHE_TIME_MS3 = 5 * 6e4;
+var resolveInfiniteQueryOptions = (options) => {
+  const staleTime = options.staleTime ?? 0;
+  const cacheTime = options.cacheTime ?? DEFAULT_CACHE_TIME_MS3;
+  return {
+    ...options,
+    staleTime,
+    cacheTime,
+    retry: options.retry ?? false,
+    retryDelay: options.retryDelay ?? 1e3,
+    keepPreviousData: options.keepPreviousData ?? false,
+    abortPrevious: options.abortPrevious ?? true,
+    staleTimeMs: toMs(staleTime, 0),
+    cacheTimeMs: toMs(cacheTime, DEFAULT_CACHE_TIME_MS3)
+  };
+};
+var resolveInfiniteInstanceOptions = (definitionOptions, instanceOptions) => {
+  const staleTime = instanceOptions?.staleTime ?? definitionOptions.staleTime ?? 0;
+  const cacheTime = instanceOptions?.cacheTime ?? definitionOptions.cacheTime ?? DEFAULT_CACHE_TIME_MS3;
+  return {
+    ...definitionOptions,
+    ...instanceOptions,
+    staleTime,
+    cacheTime,
+    staleTimeMs: toMs(staleTime, 0),
+    cacheTimeMs: toMs(cacheTime, DEFAULT_CACHE_TIME_MS3),
+    enabled: instanceOptions?.enabled ?? true,
+    refetchOnMount: instanceOptions?.refetchOnMount ?? true,
+    refetchOnWindowFocus: instanceOptions?.refetchOnWindowFocus ?? true,
+    refetchOnReconnect: instanceOptions?.refetchOnReconnect ?? true,
+    keepPreviousData: instanceOptions?.keepPreviousData ?? definitionOptions.keepPreviousData ?? false,
+    abortPrevious: instanceOptions?.abortPrevious ?? definitionOptions.abortPrevious ?? true,
+    retry: instanceOptions?.retry ?? definitionOptions.retry ?? false,
+    retryDelay: instanceOptions?.retryDelay ?? definitionOptions.retryDelay ?? 1e3,
+    onStart: instanceOptions?.onStart ?? definitionOptions.onStart,
+    onSuccess: instanceOptions?.onSuccess ?? definitionOptions.onSuccess,
+    onError: instanceOptions?.onError ?? definitionOptions.onError,
+    onSettled: instanceOptions?.onSettled ?? definitionOptions.onSettled
+  };
+};
+var resolveInfiniteDefinitionOptions = (definition) => resolveInfiniteQueryOptions(definition.options);
+
+// src/query/infinite-query-observer.ts
+var InfiniteQueryObserver = class {
+  definition;
+  client;
+  options;
+  #query = null;
+  #previousQuery = null;
+  #params;
+  #disposeParams = null;
+  #destroyed = false;
+  #listeners = /* @__PURE__ */ new Set();
+  #currentHash = null;
+  constructor(definition, client, params, instanceOptions) {
+    this.definition = definition;
+    this.client = client;
+    this.options = resolveInfiniteInstanceOptions(
+      resolveInfiniteDefinitionOptions(definition),
+      instanceOptions
+    );
+    if (typeof params === "function") {
+      this.#disposeParams = effect(() => {
+        this.setParams(params());
+      });
+    } else {
+      this.setParams(params);
+    }
+  }
+  getQuery() {
+    return this.#query;
+  }
+  getPreviousQuery() {
+    return this.#previousQuery;
+  }
+  getParams() {
+    return this.#params;
+  }
+  onInfiniteQueryUpdate() {
+    for (const listener of this.#listeners) listener();
+  }
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  setParams(params) {
+    if (this.#destroyed) return;
+    this.#params = params;
+    const queryKey = this.definition.queryKey(params);
+    const hash = hashKey(queryKey);
+    if (this.#currentHash === hash) {
+      void this.maybeFetch(false);
+      return;
+    }
+    if (this.#query) {
+      if (this.options.abortPrevious) {
+        void this.#query.cancel({ silent: true });
+      }
+      this.#detach(this.#query);
+      this.#previousQuery = this.options.keepPreviousData ? this.#query : null;
+    }
+    this.#currentHash = hash;
+    this.#query = this.client.infiniteQueryCache.build({
+      client: this.client,
+      cache: this.client.infiniteQueryCache,
+      definition: this.definition,
+      params,
+      queryKey,
+      options: this.options
+    });
+    this.#query.addObserver(this);
+    void this.maybeFetch(true);
+    this.onInfiniteQueryUpdate();
+  }
+  maybeFetch(paramsChanged) {
+    if (!this.#query || !isEnabled(this.options.enabled)) return;
+    const stale = this.#query.isStale();
+    const hasData = this.#query.hasData();
+    if (!hasData || stale) {
+      void this.#query.fetchNextPage();
+      return;
+    }
+    if (paramsChanged && this.options.refetchOnMount === true) {
+      void this.#query.refetch();
+    }
+  }
+  cancel(options) {
+    void this.#query?.cancel(options);
+  }
+  remove() {
+    if (!this.#query) return;
+    this.#detach(this.#query);
+    this.client.infiniteQueryCache.remove(this.#query);
+    this.#query = null;
+    this.#currentHash = null;
+    this.onInfiniteQueryUpdate();
+  }
+  destroy() {
+    if (this.#destroyed) return;
+    this.#destroyed = true;
+    this.#disposeParams?.();
+    if (this.#query) this.#detach(this.#query);
+    this.#listeners.clear();
+  }
+  #detach(query) {
+    query.removeObserver(this);
+  }
+};
+
+// src/query/infinite-query-instance.ts
+var effectiveInfiniteQuery = (observer) => {
+  const query = observer.getQuery();
+  if (!query) return observer.getPreviousQuery();
+  if (query.hasData()) return query;
+  const prev = observer.getPreviousQuery();
+  if (prev && observer.options.keepPreviousData) return prev;
+  return query;
+};
+var createInfiniteQueryInstance = (definition, client, params, instanceOptions) => {
+  const observer = new InfiniteQueryObserver(definition, client, params, instanceOptions);
+  const $params = signal(observer.getParams());
+  observer.subscribe(() => $params.set(observer.getParams()));
+  const readQuery = () => effectiveInfiniteQuery(observer);
+  const readData = () => {
+    const data = readQuery()?.$data.value();
+    return data ?? null;
+  };
+  const $data = computed(() => readData());
+  const $pages = computed(() => readData()?.pages ?? []);
+  const $pageParams = computed(() => readData()?.pageParams ?? []);
+  const $error = computed(() => readQuery()?.$error.value() ?? null);
+  const $pending = computed(() => {
+    const q = readQuery();
+    return q ? isQueryPending(q.$status.value()) : false;
+  });
+  const $fetching = computed(() => readQuery()?.$fetchStatus.value() === "fetching");
+  const $fetchingNextPage = computed(() => readQuery()?.$fetchingNextPage.value() ?? false);
+  const $fetchingPreviousPage = computed(
+    () => readQuery()?.$fetchingPreviousPage.value() ?? false
+  );
+  const $abortSignal = computed(() => readQuery()?.getAbortSignal() ?? null);
+  const getQuery = () => {
+    const q = observer.getQuery();
+    if (!q) throw new Error("InfiniteQueryObserver has no active query");
+    return q;
+  };
+  return {
+    kind: "infinite-query",
+    pages: () => $pages.value(),
+    pageParams: () => $pageParams.value(),
+    data: () => $data.value(),
+    flatMap: (selector) => $pages.value().flatMap((page) => selector(page)),
+    fetchNextPage: (options) => getQuery().fetchNextPage(options),
+    fetchPreviousPage: (options) => getQuery().fetchPreviousPage(options),
+    refetch: (options) => getQuery().refetch(options),
+    reset: () => getQuery().reset(),
+    cancel: (options) => observer.cancel(options),
+    abort: (reason) => observer.cancel({ reason }),
+    abortController: () => readQuery()?.getAbortController() ?? null,
+    abortSignal: () => readQuery()?.getAbortSignal() ?? null,
+    remove: () => {
+      observer.remove();
+      observer.destroy();
+    },
+    hasNextPage: () => readQuery()?.hasNextPage() ?? true,
+    hasPreviousPage: () => readQuery()?.hasPreviousPage() ?? false,
+    pending: () => $pending.value(),
+    fetching: () => $fetching.value(),
+    fetchingNextPage: () => $fetchingNextPage.value(),
+    fetchingPreviousPage: () => $fetchingPreviousPage.value(),
+    error: () => $error.value(),
+    params: () => $params.value(),
+    subscribe(listener) {
+      return observer.subscribe(() => listener($data.value()));
+    },
+    $data,
+    $pages,
+    $pageParams,
+    $pending,
+    $fetching,
+    $fetchingNextPage,
+    $fetchingPreviousPage,
+    $error,
+    $params,
+    $abortSignal
+  };
+};
+
+// src/query/infinite-query-options.ts
+var mergeInfiniteQueryDefinitionOptions = (options, config, provider) => {
+  const queryDefaults = defaultQueryOptions(config);
+  const providerDefaults = provider?.config.defaultOptions?.queries;
+  return {
+    staleTime: queryDefaults.staleTime,
+    cacheTime: queryDefaults.cacheTime,
+    retry: queryDefaults.retry,
+    retryDelay: queryDefaults.retryDelay,
+    keepPreviousData: queryDefaults.keepPreviousData,
+    abortPrevious: queryDefaults.abortPrevious,
+    ...providerDefaults,
+    ...options
+  };
+};
+
+// src/query/create-infinite-query.ts
+var createInfiniteQuery = (options, meta) => {
+  const provider = meta?.provider ?? getQueryProvider();
+  const mergedOptions = mergeInfiniteQueryDefinitionOptions(
+    options,
+    provider?.config,
+    provider
+  );
+  resolveInfiniteQueryOptions(mergedOptions);
+  const definition = {
+    kind: "infinite-query-definition",
+    name: options.name,
+    options: mergedOptions,
+    queryKey(params) {
+      return mergedOptions.queryKey(params);
+    },
+    with(params, instanceOptions) {
+      const client = instanceOptions?.client ?? provider?.client ?? getDefaultQueryClient();
+      return createInfiniteQueryInstance(definition, client, params, instanceOptions);
+    },
+    withStore(store, map, instanceOptions) {
+      const client = instanceOptions?.client ?? provider?.client ?? getDefaultQueryClient();
+      return createInfiniteQueryInstance(
+        definition,
+        client,
+        () => map(store.value()),
+        instanceOptions
+      );
+    }
+  };
+  return definition;
+};
+
+// src/core/subscribable.ts
+var Subscribable = class {
+  listeners = /* @__PURE__ */ new Set();
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notify(event) {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+};
+
+// src/utils/match-query.ts
+var matchQuery = (filters, query) => {
+  const { exact, fetchStatus, predicate, queryKey, stale } = filters;
+  if (queryKey) {
+    if (exact) {
+      if (query.queryHash !== hashKey(queryKey)) return false;
+    } else if (!partialMatchKey(query.queryKey, queryKey)) {
+      return false;
+    }
+  }
+  if (typeof stale === "boolean" && query.isStale() !== stale) return false;
+  if (fetchStatus && fetchStatus !== query.state.fetchStatus) return false;
+  if (predicate && !predicate(query)) return false;
+  return true;
+};
+
+// src/core/query-cache.ts
+var QueryCache = class extends Subscribable {
+  #queries = /* @__PURE__ */ new Map();
+  get(queryHash) {
+    return this.#queries.get(queryHash);
+  }
+  getByKey(queryKey) {
+    return this.#queries.get(hashKey(queryKey));
+  }
+  getAll() {
+    return [...this.#queries.values()];
+  }
+  build(config) {
+    const hash = hashKey(config.queryKey);
+    const cached = this.#queries.get(hash);
+    if (cached) return cached;
+    const query = new Query(config);
+    this.add(query);
+    return query;
+  }
+  add(query) {
+    if (!this.#queries.has(query.queryHash)) {
+      this.#queries.set(
+        query.queryHash,
+        query
+      );
+      this.emit({
+        type: "queryAdded",
+        queryKey: query.queryKey,
+        hash: query.queryHash
+      });
+    }
+  }
+  remove(query) {
+    const cached = this.#queries.get(query.queryHash);
+    if (cached && cached.queryHash === query.queryHash) {
+      void query.cancel({ silent: true });
+      this.#queries.delete(query.queryHash);
+      this.emit({
+        type: "queryRemoved",
+        queryKey: query.queryKey,
+        hash: query.queryHash
+      });
+    }
+  }
+  find(filters) {
+    return this.getAll().find((query) => matchQuery(filters, query));
+  }
+  findAll(filter = []) {
+    if (Array.isArray(filter)) {
+      if (filter.length === 0) return this.getAll();
+      return this.getAll().filter(
+        (query) => matchQuery({ queryKey: filter }, query)
+      );
+    }
+    const objectFilter = filter;
+    return this.getAll().filter(
+      (query) => matchQuery(
+        { queryKey: objectFilter.queryKey, exact: objectFilter.exact },
+        query
+      )
+    );
+  }
+  clear() {
+    for (const query of [...this.getAll()]) {
+      this.remove(query);
+    }
+  }
+  emit(event) {
+    this.notify(event);
+  }
+  onFocus() {
+    for (const query of this.getAll()) {
+      query.onFocus();
+    }
+  }
+  onOnline() {
+    for (const query of this.getAll()) {
+      query.onOnline();
+    }
+  }
+};
+var createQueryCache = () => new QueryCache();
+
+// src/core/infinite-query-cache.ts
+var InfiniteQueryCache = class extends Subscribable {
+  #queries = /* @__PURE__ */ new Map();
+  get(queryHash) {
+    return this.#queries.get(queryHash);
+  }
+  getByKey(queryKey) {
+    return this.#queries.get(hashKey(queryKey));
+  }
+  getAll() {
+    return [...this.#queries.values()];
+  }
+  build(config) {
+    const hash = hashKey(config.queryKey);
+    const cached = this.#queries.get(hash);
+    if (cached) return cached;
+    const query = new InfiniteQuery(config);
+    this.add(query);
+    return query;
+  }
+  add(query) {
+    if (!this.#queries.has(query.queryHash)) {
+      this.#queries.set(
+        query.queryHash,
+        query
+      );
+      this.emit({
+        type: "infiniteQueryAdded",
+        queryKey: query.queryKey,
+        hash: query.queryHash
+      });
+    }
+  }
+  remove(query) {
+    const cached = this.#queries.get(query.queryHash);
+    if (cached && cached.queryHash === query.queryHash) {
+      void query.cancel({ silent: true });
+      this.#queries.delete(query.queryHash);
+      this.emit({
+        type: "infiniteQueryRemoved",
+        queryKey: query.queryKey,
+        hash: query.queryHash
+      });
+    }
+  }
+  find(filters) {
+    return this.getAll().find((query) => matchQuery(filters, query));
+  }
+  findAll(filter = []) {
+    if (Array.isArray(filter)) {
+      if (filter.length === 0) return this.getAll();
+      return this.getAll().filter((query) => matchQuery({ queryKey: filter }, query));
+    }
+    const objectFilter = filter;
+    return this.getAll().filter(
+      (query) => matchQuery(
+        { queryKey: objectFilter.queryKey, exact: objectFilter.exact },
+        query
+      )
+    );
+  }
+  clear() {
+    for (const query of [...this.getAll()]) {
+      this.remove(query);
+    }
+  }
+  emit(event) {
+    this.notify(event);
+  }
+  onFocus() {
+    for (const query of this.getAll()) {
+      query.onFocus();
+    }
+  }
+  onOnline() {
+    for (const query of this.getAll()) {
+      query.onOnline();
+    }
+  }
+};
+var createInfiniteQueryCache = () => new InfiniteQueryCache();
+
+// src/core/mutation-cache.ts
+var MutationCache = class extends Subscribable {
+  emit(event) {
+    this.notify(event);
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+var createMutationCache = () => new MutationCache();
+
+// src/managers/register-client.ts
+var clients = /* @__PURE__ */ new Set();
+var registerClientWithManagers = (client) => {
+  clients.add(client);
+};
+var getRegisteredClients = () => clients;
+
+// src/client/query-client.ts
+var resolveKeyAndParams = (keyOrDefinition, params) => {
+  if (typeof keyOrDefinition === "object" && keyOrDefinition !== null && "kind" in keyOrDefinition) {
+    return { key: keyOrDefinition.queryKey(params) };
+  }
+  return { key: keyOrDefinition };
+};
+var QueryClient = class {
+  queryCache;
+  infiniteQueryCache;
+  mutationCache;
+  constructor(config) {
+    this.queryCache = createQueryCache();
+    this.infiniteQueryCache = createInfiniteQueryCache();
+    this.mutationCache = createMutationCache();
+    registerClientWithManagers(this);
+  }
+  async fetchQuery(definition, params, options) {
+    const resolvedParams = params ?? {};
+    const queryKey = definition.queryKey(resolvedParams);
+    const resolvedOptions = resolveInstanceOptions(
+      resolveDefinitionOptions(definition),
+      options
+    );
+    if (!isEnabled(resolvedOptions.enabled)) {
+      const cached = this.getQueryData(definition, resolvedParams);
+      if (cached === void 0) {
+        throw new Error("Query is disabled and has no cached data");
+      }
+      return cached;
+    }
+    const query = this.queryCache.build({
+      client: this,
+      cache: this.queryCache,
+      definition,
+      params: resolvedParams,
+      queryKey,
+      options: resolvedOptions
+    });
+    if (query.hasData() && !query.isStale()) {
+      return query.state.data;
+    }
+    return query.fetch();
+  }
+  async prefetchQuery(definition, params, options) {
+    await this.fetchQuery(definition, params, options);
+  }
+  async ensureQueryData(definition, params, options) {
+    return this.fetchQuery(definition, params, options);
+  }
+  getQueryData(keyOrDefinition, params) {
+    const { key } = resolveKeyAndParams(keyOrDefinition, params);
+    return this.queryCache.getByKey(key)?.state.data;
+  }
+  setQueryData(keyOrDefinition, paramsOrUpdater, updater) {
+    let key;
+    let nextUpdater;
+    if (typeof keyOrDefinition === "object" && keyOrDefinition !== null && "kind" in keyOrDefinition) {
+      key = keyOrDefinition.queryKey(paramsOrUpdater);
+      nextUpdater = typeof updater === "function" ? updater : () => updater;
+    } else {
+      key = keyOrDefinition;
+      nextUpdater = typeof paramsOrUpdater === "function" ? paramsOrUpdater : () => paramsOrUpdater;
+    }
+    const hash = hashKey(key);
+    let query = this.queryCache.get(hash);
+    if (!query) {
+      throw new Error(`Query not found for key: ${JSON.stringify(key)}`);
+    }
+    query.setData(
+      (prev) => functionalUpdate(nextUpdater, prev)
+    );
+  }
+  invalidateQueries(filter, options) {
+    const refetchMode = options?.refetch ?? "active";
+    const shouldRefetch = refetchMode !== false && refetchMode !== "none";
+    for (const query of this.queryCache.findAll(filter)) {
+      query.invalidate();
+      if (!shouldRefetch) continue;
+      if (refetchMode === "all" || query.isActive()) {
+        void query.fetch().catch(() => void 0);
+      }
+    }
+  }
+  async refetchQueries(filter) {
+    await Promise.allSettled(
+      this.queryCache.findAll(filter).map((query) => query.fetch())
+    );
+  }
+  cancelQueries(filter) {
+    for (const query of this.queryCache.findAll(filter)) {
+      void query.cancel();
+    }
+  }
+  removeQueries(filter) {
+    for (const query of [...this.queryCache.findAll(filter)]) {
+      this.queryCache.remove(query);
+    }
+  }
+  clear() {
+    this.queryCache.clear();
+    this.infiniteQueryCache.clear();
+    this.mutationCache.clear();
+  }
+};
+var createQueryClient = (config) => {
+  const client = new QueryClient(config);
+  setDefaultQueryClient(client);
+  registerDefaultQueryClientFactory(() => client);
+  return client;
+};
+var mutationIdCounter = 0;
+var Mutation = class {
+  id;
+  definition;
+  client;
+  cache;
+  $data;
+  $error;
+  $variables;
+  $status;
+  $pendingCount;
+  #abortController;
+  #abortDispose;
+  constructor(definition, client, cache) {
+    mutationIdCounter += 1;
+    this.id = mutationIdCounter;
+    this.definition = definition;
+    this.client = client;
+    this.cache = cache;
+    this.$data = signal(void 0);
+    this.$error = signal(null);
+    this.$variables = signal(void 0);
+    this.$status = signal("idle");
+    this.$pendingCount = signal(0);
+  }
+  getAbortController() {
+    return this.#abortController;
+  }
+  getAbortSignal() {
+    return this.#abortController?.signal;
+  }
+  async run(variables, runOptions) {
+    const abortHandle = createFetchAbortHandle(
+      mergeFetchAbortSource(this.definition.options, runOptions)
+    );
+    this.#abortController = abortHandle.controller;
+    this.#abortDispose = abortHandle.dispose;
+    const { controller: abortController, signal: signal8 } = abortHandle;
+    this.$variables.set(variables);
+    this.$status.set("pending");
+    this.$pendingCount.set(this.$pendingCount.peek() + 1);
+    this.cache.emit({ type: "mutationAdded", mutationId: this.id });
+    let rollback;
+    const lifecycleCtx = {
+      variables,
+      queryClient: this.client
+    };
+    try {
+      const mutateResult = await this.definition.options.onMutate?.({
+        ...lifecycleCtx
+      });
+      if (typeof mutateResult !== "undefined") {
+        rollback = mutateResult;
+      }
+      const retryer = createRetryer({
+        fn: () => this.definition.options.mutationFn({
+          variables,
+          signal: signal8,
+          abortController,
+          queryClient: this.client
+        }),
+        onCancel: () => abortHandle.abort(),
+        retry: this.definition.options.retry,
+        retryDelay: this.definition.options.retryDelay
+      });
+      const data = await retryer.start();
+      this.$data.set(data);
+      this.$error.set(null);
+      this.$status.set("success");
+      this.definition.options.onSuccess?.({
+        ...lifecycleCtx,
+        data,
+        rollback
+      });
+      this.cache.emit({ type: "mutationUpdated", mutationId: this.id });
+      return data;
+    } catch (error) {
+      if (!isCancelledError(error) && !isAbortError(error)) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.$error.set(err);
+        this.$status.set("error");
+        this.definition.options.onError?.({
+          ...lifecycleCtx,
+          error: err,
+          rollback
+        });
+      }
+      throw error;
+    } finally {
+      this.$pendingCount.set(Math.max(0, this.$pendingCount.peek() - 1));
+      this.#clearAbortHandle();
+      this.definition.options.onSettled?.({
+        ...lifecycleCtx,
+        data: this.$data.peek(),
+        error: this.$error.peek(),
+        rollback
+      });
+      this.cache.emit({ type: "mutationUpdated", mutationId: this.id });
+    }
+  }
+  cancel(options) {
+    abortWithReason(this.#abortController, options?.reason);
+  }
+  #clearAbortHandle() {
+    this.#abortDispose?.();
+    this.#abortDispose = void 0;
+    this.#abortController = void 0;
+  }
+  reset() {
+    this.$data.set(void 0);
+    this.$error.set(null);
+    this.$variables.set(void 0);
+    this.$status.set("idle");
+    this.$pendingCount.set(0);
+  }
+  toInstance() {
+    const mutation = this;
+    const $data = computed(() => mutation.$data.value());
+    const $error = computed(() => mutation.$error.value());
+    const $variables = computed(
+      () => mutation.$variables.value()
+    );
+    const $status = computed(() => mutation.$status.value());
+    const $pendingCount = computed(() => mutation.$pendingCount.value());
+    const $abortSignal = computed(() => mutation.getAbortSignal() ?? null);
+    return {
+      kind: "mutation-instance",
+      run: (variables, options) => mutation.run(variables, options),
+      reset: () => mutation.reset(),
+      cancel: (options) => mutation.cancel(options),
+      abort: (reason) => mutation.cancel({ reason }),
+      abortController: () => mutation.getAbortController() ?? null,
+      abortSignal: () => mutation.getAbortSignal() ?? null,
+      data: () => $data.value(),
+      error: () => $error.value(),
+      variables: () => $variables.value(),
+      status: () => $status.value(),
+      pending: () => $status.value() === "pending",
+      isPending: () => $status.value() === "pending",
+      isSuccess: () => $status.value() === "success",
+      isError: () => $status.value() === "error",
+      isIdle: () => $status.value() === "idle",
+      $data,
+      $error,
+      $variables,
+      $status,
+      $pendingCount,
+      $abortSignal
+    };
+  }
+};
+
+// src/mutation/mutation-instance.ts
+var createMutationInstance = (definition, client) => {
+  const mutation = new Mutation(definition, client, client.mutationCache);
+  return mutation.toInstance();
+};
+
+// src/mutation/create-mutation.ts
+var createMutation = (options, meta) => {
+  const provider = meta?.provider ?? getQueryProvider();
+  const mergedOptions = {
+    ...provider?.config.defaultOptions?.mutations,
+    ...options
+  };
+  return {
+    kind: "mutation-definition",
+    name: mergedOptions.name,
+    options: mergedOptions,
+    create(opts) {
+      const client = opts?.client ?? provider?.client ?? getDefaultQueryClient();
+      return createMutationInstance(
+        {
+          kind: "mutation-definition",
+          name: mergedOptions.name,
+          options: mergedOptions,
+          create: this.create
+        },
+        client
+      );
+    }
+  };
+};
+
+// src/provider/query-provider.ts
+var QueryProvider = class {
+  client;
+  config;
+  constructor(config = {}) {
+    this.client = config.client ?? createQueryClient(config);
+    this.config = { ...config, client: this.client };
+  }
+  createQuery = (options) => createQuery(options, { provider: this });
+  createMutation = (options) => createMutation(options, { provider: this });
+  createInfiniteQuery = (options) => createInfiniteQuery(options, { provider: this });
+  invalidateQueries(filter, options) {
+    this.client.invalidateQueries(filter, options);
+  }
+  refetchQueries(filter) {
+    return this.client.refetchQueries(filter);
+  }
+  cancelQueries(filter) {
+    this.client.cancelQueries(filter);
+  }
+  removeQueries(filter) {
+    this.client.removeQueries(filter);
+  }
+};
+var setQueryProvider = (provider) => {
+  setActiveQueryProvider(provider);
+  setDefaultQueryClient(provider.client);
+};
+
+// src/plugin/query-plugin.ts
+var QUERY_PROVIDER_KEY = /* @__PURE__ */ Symbol.for("echojs.query.provider");
+var createQueryProvider = (config = {}) => {
+  const provider = new QueryProvider(config);
+  setQueryProvider(provider);
+  return {
+    name: "query",
+    provider,
+    setup(app) {
+      app.provide?.(QUERY_PROVIDER_KEY, provider);
+    }
+  };
+};
+var createQueryPlugin = createQueryProvider;
+var queryPlugin = createQueryProvider;
+
+// src/managers/refetch-stale.ts
+var refetchStaleActiveQueries = (_client, reason) => {
+  for (const client of getRegisteredClients()) {
+    if (reason === "focus") {
+      client.queryCache.onFocus();
+      client.infiniteQueryCache.onFocus();
+    } else {
+      client.queryCache.onOnline();
+      client.infiniteQueryCache.onOnline();
+    }
+  }
+};
+
+// src/managers/focus-manager.ts
+var FocusManager = class {
+  #focused = signal(
+    typeof document !== "undefined" ? document.visibilityState === "visible" : true
+  );
+  constructor() {
+    if (typeof window !== "undefined" && typeof document !== "undefined") {
+      const onVisibility = () => {
+        this.setFocused(document.visibilityState === "visible");
+      };
+      document.addEventListener("visibilitychange", onVisibility);
+      window.addEventListener("focus", () => this.setFocused(true));
+    }
+  }
+  isFocused() {
+    return this.#focused.value();
+  }
+  setFocused(focused) {
+    this.#focused.set(focused);
+    if (focused) {
+      for (const client of getRegisteredClients()) {
+        refetchStaleActiveQueries(client, "focus");
+      }
+    }
+  }
+  subscribe(listener) {
+    return this.#focused.subscribe(() => listener(this.#focused.value()));
+  }
+  onClientRegistered(client) {
+    if (this.isFocused()) {
+      refetchStaleActiveQueries(client, "focus");
+    }
+  }
+};
+var focusManager = new FocusManager();
+var readOnline = () => {
+  if (typeof navigator !== "undefined" && typeof navigator.onLine === "boolean") {
+    return navigator.onLine;
+  }
+  return true;
+};
+var OnlineManager = class {
+  #online = signal(readOnline());
+  constructor() {
+    if (typeof window !== "undefined") {
+      window.addEventListener("online", () => this.setOnline(true));
+      window.addEventListener("offline", () => this.setOnline(false));
+    }
+  }
+  isOnline() {
+    return this.#online.value();
+  }
+  setOnline(online) {
+    const prev = this.#online.peek();
+    this.#online.set(online);
+    if (!prev && online) {
+      for (const client of getRegisteredClients()) {
+        refetchStaleActiveQueries(client, "reconnect");
+      }
+    }
+  }
+  subscribe(listener) {
+    return this.#online.subscribe(() => listener(this.#online.value()));
+  }
+  onClientRegistered(client) {
+    if (this.isOnline()) {
+      refetchStaleActiveQueries(client, "reconnect");
+    }
+  }
+};
+var onlineManager = new OnlineManager();
+
+export { CancelledError, FocusManager, InfiniteQuery, InfiniteQueryCache, InfiniteQueryObserver, Mutation, MutationCache, OnlineManager, QUERY_PROVIDER_KEY, Query, QueryCache, QueryClient, QueryObserver, QueryProvider, abortWithReason, createFetchAbortHandle, createInfiniteQuery, createMutation, createQuery, createQueryClient, createQueryPlugin, createQueryProvider, focusManager, getDefaultQueryClient, getQueryProvider, hasInfiniteNextPage, hasInfinitePreviousPage, hashKey, isCancelledError, matchQuery, mergeFetchAbortSource, onlineManager, partialMatchKey, queryPlugin, requireQueryProvider, resetQueryProvider, resolveAbortInput, setDefaultQueryClient, setQueryProvider };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map