@epoch32/visage 1.1.3 → 1.1.4

package/dist/index-y9bq7h9g.js

@@ -0,0 +1,1162 @@
+import {
+  SIGNAL_BRAND2,
+  COMPUTED_BRAND2,
+  untrack2,
+  computed2,
+  onCleanup2,
+  createContext2,
+  useContext2,
+  effect2,
+  signal2
+} from "./index-6kfe1nr4.js";
+import {
+  SuspenseContext2
+} from "./index-a4xns6cc.js";
+
+// src/query/focus-manager.ts
+class FocusManager2 {
+  _focused;
+  _listeners = new Set;
+  _cleanup;
+  constructor() {
+    this.setupEventListener();
+  }
+  setupEventListener() {
+    if (typeof window === "undefined" || typeof window.addEventListener === "undefined") {
+      return;
+    }
+    const listener = () => {
+      this.notify(this.isFocused());
+    };
+    window.addEventListener("visibilitychange", listener, false);
+    window.addEventListener("focus", listener, false);
+    this._cleanup = () => {
+      window.removeEventListener("visibilitychange", listener);
+      window.removeEventListener("focus", listener);
+    };
+  }
+  setFocused(focused) {
+    this._focused = focused;
+    this.notify(this.isFocused());
+  }
+  isFocused() {
+    if (typeof this._focused === "boolean") {
+      return this._focused;
+    }
+    if (typeof document !== "undefined" && typeof document.visibilityState === "string") {
+      return document.visibilityState !== "hidden";
+    }
+    return true;
+  }
+  subscribe(listener) {
+    this._listeners.add(listener);
+    return () => {
+      this._listeners.delete(listener);
+    };
+  }
+  notify(focused) {
+    for (const listener of this._listeners) {
+      try {
+        listener(focused);
+      } catch (err) {
+        console.error("Error in focus listener:", err);
+      }
+    }
+  }
+  cleanup() {
+    this._cleanup?.();
+    this._listeners.clear();
+  }
+}
+var focusManager2 = new FocusManager2;
+
+// src/query/mutation-cache.ts
+class Mutation2 {
+  options;
+  data;
+  error;
+  status;
+  submittedAt;
+  variables;
+  isIdle;
+  isPending;
+  isLoading;
+  isSuccess;
+  isError;
+  constructor(options) {
+    this.options = options;
+    this.data = signal2(undefined);
+    this.error = signal2(null);
+    this.status = signal2("idle");
+    this.submittedAt = signal2(0);
+    this.variables = signal2(undefined);
+    this.isIdle = computed2(() => this.status() === "idle");
+    this.isPending = computed2(() => this.status() === "pending");
+    this.isLoading = this.isPending;
+    this.isSuccess = computed2(() => this.status() === "success");
+    this.isError = computed2(() => this.status() === "error");
+  }
+  async execute(variables, mutateOptions) {
+    this.status.set("pending");
+    this.error.set(null);
+    this.variables.set(variables);
+    this.submittedAt.set(Date.now());
+    let context;
+    try {
+      if (this.options.onMutate) {
+        const res = await this.options.onMutate(variables);
+        if (res !== undefined) {
+          context = res;
+        }
+      }
+      const result = await this.options.mutationFn(variables);
+      this.data.set(result);
+      this.status.set("success");
+      try {
+        await this.options.onSuccess?.(result, variables, context);
+      } catch (err) {
+        console.error("Error in mutation onSuccess:", err);
+      }
+      try {
+        mutateOptions?.onSuccess?.(result, variables, context);
+      } catch (err) {
+        console.error("Error in mutateOptions onSuccess:", err);
+      }
+      try {
+        await this.options.onSettled?.(result, null, variables, context);
+      } catch (err) {
+        console.error("Error in mutation onSettled:", err);
+      }
+      try {
+        mutateOptions?.onSettled?.(result, null, variables, context);
+      } catch (err) {
+        console.error("Error in mutateOptions onSettled:", err);
+      }
+      return result;
+    } catch (err) {
+      this.error.set(err);
+      this.status.set("error");
+      try {
+        await this.options.onError?.(err, variables, context);
+      } catch (e) {
+        console.error("Error in mutation onError:", e);
+      }
+      try {
+        mutateOptions?.onError?.(err, variables, context);
+      } catch (e) {
+        console.error("Error in mutateOptions onError:", e);
+      }
+      try {
+        await this.options.onSettled?.(undefined, err, variables, context);
+      } catch (e) {
+        console.error("Error in mutation onSettled:", e);
+      }
+      try {
+        mutateOptions?.onSettled?.(undefined, err, variables, context);
+      } catch (e) {
+        console.error("Error in mutateOptions onSettled:", e);
+      }
+      throw err;
+    }
+  }
+  reset() {
+    this.data.set(undefined);
+    this.error.set(null);
+    this.status.set("idle");
+    this.submittedAt.set(0);
+    this.variables.set(undefined);
+  }
+}
+
+class MutationCache2 {
+  mutations = new Set;
+  build(options) {
+    const mutation = new Mutation2(options);
+    this.mutations.add(mutation);
+    return mutation;
+  }
+  remove(mutation) {
+    this.mutations.delete(mutation);
+  }
+  clear() {
+    this.mutations.clear();
+  }
+}
+
+// src/query/online-manager.ts
+class OnlineManager2 {
+  _online;
+  _listeners = new Set;
+  _cleanup;
+  constructor() {
+    this.setupEventListener();
+  }
+  setupEventListener() {
+    if (typeof window === "undefined" || typeof window.addEventListener === "undefined") {
+      return;
+    }
+    const onlineListener = () => this.notify(true);
+    const offlineListener = () => this.notify(false);
+    window.addEventListener("online", onlineListener, false);
+    window.addEventListener("offline", offlineListener, false);
+    this._cleanup = () => {
+      window.removeEventListener("online", onlineListener);
+      window.removeEventListener("offline", offlineListener);
+    };
+  }
+  setOnline(online) {
+    this._online = online;
+    this.notify(this.isOnline());
+  }
+  isOnline() {
+    if (typeof this._online === "boolean") {
+      return this._online;
+    }
+    if (typeof navigator !== "undefined" && typeof navigator.onLine === "boolean") {
+      return navigator.onLine;
+    }
+    return true;
+  }
+  subscribe(listener) {
+    this._listeners.add(listener);
+    return () => {
+      this._listeners.delete(listener);
+    };
+  }
+  notify(online) {
+    for (const listener of this._listeners) {
+      try {
+        listener(online);
+      } catch (err) {
+        console.error("Error in online listener:", err);
+      }
+    }
+  }
+  cleanup() {
+    this._cleanup?.();
+    this._listeners.clear();
+  }
+}
+var onlineManager2 = new OnlineManager2;
+
+// src/query/utils.ts
+function isPlainObject2(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+function hashKey2(queryKey) {
+  return JSON.stringify(queryKey, (_key, val) => {
+    if (isPlainObject2(val)) {
+      return Object.keys(val).sort().reduce((result, k) => {
+        result[k] = val[k];
+        return result;
+      }, {});
+    }
+    return val;
+  });
+}
+function deepEqual2(a, b) {
+  if (Object.is(a, b))
+    return true;
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+    return false;
+  }
+  if (Array.isArray(a) !== Array.isArray(b))
+    return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length)
+      return false;
+    for (let i = 0;i < a.length; i++) {
+      if (!deepEqual2(a[i], b[i]))
+        return false;
+    }
+    return true;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length)
+    return false;
+  for (const key of keysA) {
+    if (!Object.hasOwn(b, key))
+      return false;
+    if (!deepEqual2(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function partialDeepEqual2(a, b) {
+  if (Object.is(a, b))
+    return true;
+  if (a === undefined || a === null || b === undefined || b === null) {
+    return a === b;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length > b.length)
+      return false;
+    for (let i = 0;i < a.length; i++) {
+      if (!partialDeepEqual2(a[i], b[i]))
+        return false;
+    }
+    return true;
+  }
+  if (isPlainObject2(a) && isPlainObject2(b)) {
+    for (const key of Object.keys(a)) {
+      if (!(key in b))
+        return false;
+      if (!partialDeepEqual2(a[key], b[key]))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function matchQuery2(filters, query) {
+  if (!filters)
+    return true;
+  if (filters.queryKey !== undefined) {
+    const filterKey = Array.isArray(filters.queryKey) ? filters.queryKey : [filters.queryKey];
+    const queryKey = Array.isArray(query.queryKey) ? query.queryKey : [query.queryKey];
+    if (filters.exact) {
+      if (filterKey.length !== queryKey.length)
+        return false;
+      if (!deepEqual2(filterKey, queryKey))
+        return false;
+    } else {
+      if (filterKey.length > queryKey.length)
+        return false;
+      for (let i = 0;i < filterKey.length; i++) {
+        if (!partialDeepEqual2(filterKey[i], queryKey[i])) {
+          return false;
+        }
+      }
+    }
+  }
+  if (filters.type === "active" && query.observers.size === 0) {
+    return false;
+  }
+  if (filters.type === "inactive" && query.observers.size > 0) {
+    return false;
+  }
+  if (filters.stale !== undefined && query.isStale() !== filters.stale) {
+    return false;
+  }
+  if (filters.fetchStatus !== undefined && query.fetchStatus() !== filters.fetchStatus) {
+    return false;
+  }
+  if (filters.predicate && !filters.predicate(query)) {
+    return false;
+  }
+  return true;
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/query/query-cache.ts
+function shouldRetry(failureCount, error, retry) {
+  if (retry === false)
+    return false;
+  if (retry === true)
+    return true;
+  if (typeof retry === "number")
+    return failureCount <= retry;
+  if (typeof retry === "function")
+    return retry(failureCount, error);
+  return failureCount < 3;
+}
+function getRetryDelay(attempt, error, retryDelay) {
+  if (typeof retryDelay === "function")
+    return retryDelay(attempt, error);
+  if (typeof retryDelay === "number")
+    return retryDelay;
+  return Math.min(1000 * 2 ** attempt, 30000);
+}
+
+class Query2 {
+  queryKey;
+  queryHash;
+  cache;
+  data;
+  error;
+  status;
+  fetchStatus;
+  dataUpdatedAt;
+  errorUpdatedAt;
+  failureCount;
+  isInvalidated;
+  observers = new Set;
+  _gcTimeout = null;
+  _abortController = null;
+  promise = null;
+  defaultGcTime = 5 * 60 * 1000;
+  constructor(options) {
+    this.queryKey = options.queryKey;
+    this.queryHash = options.queryHash;
+    this.cache = options.cache;
+    const initialData = typeof options.initialData === "function" ? options.initialData() : options.initialData;
+    const initialUpdatedAt = initialData !== undefined ? typeof options.initialDataUpdatedAt === "function" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt ?? Date.now() : 0;
+    this.data = signal2(initialData);
+    this.error = signal2(null);
+    this.status = signal2(initialData !== undefined ? "success" : "pending");
+    this.fetchStatus = signal2("idle");
+    this.dataUpdatedAt = signal2(initialUpdatedAt);
+    this.errorUpdatedAt = signal2(0);
+    this.failureCount = signal2(0);
+    this.isInvalidated = signal2(false);
+  }
+  get state() {
+    return {
+      data: this.data(),
+      error: this.error(),
+      status: this.status(),
+      fetchStatus: this.fetchStatus(),
+      dataUpdatedAt: this.dataUpdatedAt(),
+      errorUpdatedAt: this.errorUpdatedAt(),
+      failureCount: this.failureCount(),
+      isInvalidated: this.isInvalidated()
+    };
+  }
+  isStale(staleTime = 0) {
+    if (this.isInvalidated())
+      return true;
+    if (this.dataUpdatedAt() === 0)
+      return true;
+    if (staleTime === Number.POSITIVE_INFINITY)
+      return false;
+    return Date.now() - this.dataUpdatedAt() >= staleTime;
+  }
+  addObserver(observer) {
+    this.observers.add(observer);
+    this.clearGcTimeout();
+  }
+  removeObserver(observer) {
+    this.observers.delete(observer);
+    if (this.observers.size === 0) {
+      this.scheduleGc(observer.options.gcTime);
+    }
+  }
+  scheduleGc(gcTime) {
+    this.clearGcTimeout();
+    const duration = gcTime !== undefined ? gcTime : this.defaultGcTime;
+    if (duration === Number.POSITIVE_INFINITY)
+      return;
+    if (duration <= 0) {
+      this.cache.remove(this);
+      return;
+    }
+    this._gcTimeout = setTimeout(() => {
+      if (this.observers.size === 0) {
+        this.cache.remove(this);
+      }
+    }, duration);
+  }
+  clearGcTimeout() {
+    if (this._gcTimeout !== null) {
+      clearTimeout(this._gcTimeout);
+      this._gcTimeout = null;
+    }
+  }
+  setData(updater, options) {
+    const prev = this.data();
+    const nextData = typeof updater === "function" ? updater(prev) : updater;
+    this.data.set(nextData);
+    this.error.set(null);
+    this.status.set("success");
+    this.isInvalidated.set(false);
+    this.dataUpdatedAt.set(options?.updatedAt ?? Date.now());
+    this.notifyObservers();
+    this.cache.notify({ type: "updated", query: this });
+    return nextData;
+  }
+  invalidate() {
+    this.isInvalidated.set(true);
+    if (this.observers.size > 0) {
+      for (const observer of this.observers) {
+        observer.onQueryUpdate();
+      }
+    }
+  }
+  cancel() {
+    if (this._abortController) {
+      this._abortController.abort();
+      this._abortController = null;
+    }
+    this.fetchStatus.set("idle");
+    this.promise = null;
+  }
+  reset() {
+    this.cancel();
+    this.data.set(undefined);
+    this.error.set(null);
+    this.status.set("pending");
+    this.fetchStatus.set("idle");
+    this.dataUpdatedAt.set(0);
+    this.errorUpdatedAt.set(0);
+    this.failureCount.set(0);
+    this.isInvalidated.set(false);
+    this.notifyObservers();
+  }
+  async fetch(options, fetchOptions) {
+    if (this.promise && !fetchOptions?.cancelRefetch) {
+      return this.promise;
+    }
+    if (this._abortController && fetchOptions?.cancelRefetch) {
+      this.cancel();
+    }
+    const controller = new AbortController;
+    this._abortController = controller;
+    this.fetchStatus.set("fetching");
+    const queryFn = options?.queryFn;
+    if (!queryFn) {
+      this.fetchStatus.set("idle");
+      throw new Error(`Missing queryFn for queryKey: ${JSON.stringify(this.queryKey)}`);
+    }
+    const execFetch = async () => {
+      let attempt = 0;
+      while (true) {
+        if (controller.signal.aborted) {
+          this.fetchStatus.set("idle");
+          this.promise = null;
+          throw new Error("Query was cancelled");
+        }
+        try {
+          const result = await queryFn({
+            queryKey: this.queryKey,
+            signal: controller.signal,
+            meta: options?.meta
+          });
+          if (controller.signal.aborted) {
+            throw new Error("Query was cancelled");
+          }
+          this.setData(result);
+          this.failureCount.set(0);
+          this.fetchStatus.set("idle");
+          this.promise = null;
+          return result;
+        } catch (err) {
+          if (controller.signal.aborted) {
+            this.fetchStatus.set("idle");
+            this.promise = null;
+            throw err;
+          }
+          attempt++;
+          this.failureCount.set(attempt);
+          const canRetry = shouldRetry(attempt, err, options?.retry);
+          if (canRetry) {
+            const delay = getRetryDelay(attempt, err, options?.retryDelay);
+            if (delay > 0) {
+              await sleep2(delay);
+            }
+            continue;
+          }
+          this.error.set(err);
+          this.errorUpdatedAt.set(Date.now());
+          this.status.set("error");
+          this.fetchStatus.set("idle");
+          this.promise = null;
+          this.notifyObservers();
+          throw err;
+        }
+      }
+    };
+    this.promise = execFetch();
+    return this.promise;
+  }
+  notifyObservers() {
+    for (const observer of this.observers) {
+      observer.onQueryUpdate();
+    }
+  }
+  destroy() {
+    this.cancel();
+    this.clearGcTimeout();
+    this.observers.clear();
+  }
+}
+
+class QueryCache2 {
+  queries = new Map;
+  _subscribers = new Set;
+  subscribe(listener) {
+    this._subscribers.add(listener);
+    return () => this._subscribers.delete(listener);
+  }
+  notify(event) {
+    for (const sub of this._subscribers) {
+      sub(event);
+    }
+  }
+  getAll() {
+    return Array.from(this.queries.values());
+  }
+  build(_client, options) {
+    const queryHash = hashKey2(options.queryKey);
+    let query = this.queries.get(queryHash);
+    if (!query) {
+      query = new Query2({
+        queryKey: options.queryKey,
+        queryHash,
+        cache: this,
+        initialData: options.initialData,
+        initialDataUpdatedAt: options.initialDataUpdatedAt
+      });
+      this.add(query);
+    }
+    return query;
+  }
+  get(queryHash) {
+    return this.queries.get(queryHash);
+  }
+  add(query) {
+    this.queries.set(query.queryHash, query);
+    this.notify({ type: "added", query });
+  }
+  remove(query) {
+    const existing = this.queries.get(query.queryHash);
+    if (existing) {
+      existing.destroy();
+      this.queries.delete(query.queryHash);
+      this.notify({ type: "removed", query: existing });
+    }
+  }
+  find(filters) {
+    return this.findAll(filters)[0];
+  }
+  findAll(filters) {
+    const results = [];
+    for (const query of this.queries.values()) {
+      if (matchQuery2(filters, query)) {
+        results.push(query);
+      }
+    }
+    return results;
+  }
+  clear() {
+    for (const query of this.queries.values()) {
+      query.destroy();
+    }
+    this.queries.clear();
+    this.notify({ type: "cleared" });
+  }
+}
+
+// src/query/query-client.ts
+class QueryClient2 {
+  queryCache;
+  mutationCache;
+  defaultOptions;
+  _unsubscribeFocus;
+  _unsubscribeOnline;
+  _isMounted = false;
+  constructor(config = {}) {
+    this.defaultOptions = config.defaultOptions ?? {};
+    this.queryCache = config.queryCache ?? new QueryCache2;
+    this.mutationCache = config.mutationCache ?? new MutationCache2;
+    this.mount();
+    if (typeof window !== "undefined" && window.__VISAGE_DEVTOOLS__) {
+      window.__VISAGE_DEVTOOLS__.attachQueryClient(this);
+    }
+  }
+  mount() {
+    if (this._isMounted)
+      return;
+    this._isMounted = true;
+    this._unsubscribeFocus = focusManager2.subscribe((focused) => {
+      if (focused) {
+        this.onWindowFocus();
+      }
+    });
+    this._unsubscribeOnline = onlineManager2.subscribe((online) => {
+      if (online) {
+        this.onOnline();
+      }
+    });
+  }
+  unmount() {
+    this._isMounted = false;
+    this._unsubscribeFocus?.();
+    this._unsubscribeOnline?.();
+  }
+  onWindowFocus() {
+    const activeQueries = this.queryCache.findAll({ type: "active" });
+    for (const query of activeQueries) {
+      const observer = Array.from(query.observers)[0];
+      const options = observer?.options ?? this.defaultOptions.queries ?? {};
+      const refetchOnFocus = options.refetchOnWindowFocus ?? true;
+      if (refetchOnFocus === "always" || refetchOnFocus && query.isStale(options.staleTime)) {
+        query.fetch(options).catch(() => {});
+      }
+    }
+  }
+  onOnline() {
+    const activeQueries = this.queryCache.findAll({ type: "active" });
+    for (const query of activeQueries) {
+      const observer = Array.from(query.observers)[0];
+      const options = observer?.options ?? this.defaultOptions.queries ?? {};
+      const refetchOnReconnect = options.refetchOnReconnect ?? true;
+      if (refetchOnReconnect === "always" || refetchOnReconnect && query.isStale(options.staleTime)) {
+        query.fetch(options).catch(() => {});
+      }
+    }
+  }
+  getDefaultOptions() {
+    return this.defaultOptions;
+  }
+  setDefaultOptions(options) {
+    this.defaultOptions = options;
+  }
+  getQueryCache() {
+    return this.queryCache;
+  }
+  getMutationCache() {
+    return this.mutationCache;
+  }
+  getQueryData(queryKey) {
+    const queryHash = hashKey2(queryKey);
+    const query = this.queryCache.get(queryHash);
+    return query?.data();
+  }
+  setQueryData(queryKey, updater, options) {
+    const query = this.queryCache.build(this, {
+      queryKey,
+      ...this.defaultOptions.queries
+    });
+    return query.setData(updater, options);
+  }
+  getQueryState(queryKey) {
+    const queryHash = hashKey2(queryKey);
+    const query = this.queryCache.get(queryHash);
+    return query?.state;
+  }
+  async fetchQuery(options) {
+    const mergedOptions = {
+      ...this.defaultOptions.queries,
+      ...options
+    };
+    const query = this.queryCache.build(this, mergedOptions);
+    if (!query.isStale(mergedOptions.staleTime) && query.data() !== undefined) {
+      return query.data();
+    }
+    return query.fetch(mergedOptions);
+  }
+  async prefetchQuery(options) {
+    try {
+      await this.fetchQuery(options);
+    } catch {}
+  }
+  async invalidateQueries(filters) {
+    const queries = this.queryCache.findAll(filters);
+    const promises = [];
+    for (const query of queries) {
+      query.invalidate();
+      if (query.observers.size > 0) {
+        const observer = Array.from(query.observers)[0];
+        const options = observer?.options ?? this.defaultOptions.queries ?? {};
+        promises.push(query.fetch(options).catch(() => {}));
+      }
+    }
+    await Promise.all(promises);
+  }
+  async refetchQueries(filters) {
+    const queries = this.queryCache.findAll(filters);
+    const promises = [];
+    for (const query of queries) {
+      if (query.observers.size > 0) {
+        const observer = Array.from(query.observers)[0];
+        const options = observer?.options ?? this.defaultOptions.queries ?? {};
+        promises.push(query.fetch(options, { cancelRefetch: true }).catch(() => {}));
+      }
+    }
+    await Promise.all(promises);
+  }
+  cancelQueries(filters) {
+    const queries = this.queryCache.findAll(filters);
+    for (const query of queries) {
+      query.cancel();
+    }
+  }
+  removeQueries(filters) {
+    const queries = this.queryCache.findAll(filters);
+    for (const query of queries) {
+      this.queryCache.remove(query);
+    }
+  }
+  async resetQueries(filters) {
+    const queries = this.queryCache.findAll(filters);
+    const promises = [];
+    for (const query of queries) {
+      query.reset();
+      if (query.observers.size > 0) {
+        const observer = Array.from(query.observers)[0];
+        const options = observer?.options ?? this.defaultOptions.queries ?? {};
+        promises.push(query.fetch(options).catch(() => {}));
+      }
+    }
+    await Promise.all(promises);
+  }
+  clear() {
+    this.queryCache.clear();
+    this.mutationCache.clear();
+  }
+}
+var QueryClientContext2 = createContext2(null);
+var defaultGlobalClient = null;
+function getDefaultGlobalClient() {
+  if (!defaultGlobalClient) {
+    defaultGlobalClient = new QueryClient2;
+  }
+  return defaultGlobalClient;
+}
+function QueryClientProvider2(props) {
+  return QueryClientContext2.Provider({
+    value: props.client,
+    children: props.children
+  });
+}
+function useQueryClient2(client) {
+  if (client)
+    return client;
+  const ctxClient = useContext2(QueryClientContext2);
+  return ctxClient ?? getDefaultGlobalClient();
+}
+
+// src/query/create-mutation.ts
+function createMutation2(options, client) {
+  const queryClient = useQueryClient2(client);
+  const resolveOptions = () => typeof options === "function" ? options() : options;
+  const defaults = queryClient.getDefaultOptions().mutations ?? {};
+  const mergedOpts = { ...defaults, ...resolveOptions() };
+  const mutation = queryClient.mutationCache.build(mergedOpts);
+  const mutate = (variables, mutateOptions) => {
+    mutation.execute(variables, mutateOptions).catch(() => {});
+  };
+  const mutateAsync = (variables, mutateOptions) => {
+    return mutation.execute(variables, mutateOptions);
+  };
+  const accessor = () => {
+    return mutation.data();
+  };
+  Object.defineProperties(accessor, {
+    [SIGNAL_BRAND2]: { value: true },
+    [COMPUTED_BRAND2]: { value: true },
+    value: { get: () => mutation.data() },
+    mutate: { value: mutate },
+    mutateAsync: { value: mutateAsync },
+    data: { get: () => mutation.data },
+    error: { get: () => mutation.error },
+    status: { get: () => mutation.status },
+    isIdle: { get: () => mutation.isIdle },
+    isPending: { get: () => mutation.isPending },
+    isLoading: { get: () => mutation.isLoading },
+    isSuccess: { get: () => mutation.isSuccess },
+    isError: { get: () => mutation.isError },
+    reset: { value: () => mutation.reset() },
+    variables: { get: () => mutation.variables },
+    submittedAt: { get: () => mutation.submittedAt }
+  });
+  return accessor;
+}
+
+// src/query/create-query.ts
+function createQuery2(options, client) {
+  const queryClient = useQueryClient2(client);
+  const resolveOptions = () => typeof options === "function" ? options() : options;
+  const currentQuery = signal2(null);
+  const version = signal2(0);
+  let activeObserver = null;
+  let intervalTimer = null;
+  const clearIntervalTimer = () => {
+    if (intervalTimer !== null) {
+      clearInterval(intervalTimer);
+      intervalTimer = null;
+    }
+  };
+  effect2(() => {
+    const rawOpts = resolveOptions();
+    const defaults = queryClient.getDefaultOptions().queries ?? {};
+    const mergedOpts = {
+      ...defaults,
+      ...rawOpts
+    };
+    const isEnabled = typeof mergedOpts.enabled === "function" ? mergedOpts.enabled() : mergedOpts.enabled !== false;
+    const targetQuery = queryClient.queryCache.build(queryClient, mergedOpts);
+    if (untrack2(currentQuery) !== targetQuery || !activeObserver) {
+      const prevQ = untrack2(currentQuery);
+      if (prevQ && activeObserver) {
+        prevQ.removeObserver(activeObserver);
+      }
+      const observer = {
+        options: mergedOpts,
+        onQueryUpdate: () => {
+          version.update((v) => v + 1);
+        }
+      };
+      targetQuery.addObserver(observer);
+      activeObserver = observer;
+      currentQuery.set(targetQuery);
+    } else if (activeObserver) {
+      activeObserver.options = mergedOpts;
+    }
+    clearIntervalTimer();
+    const refetchInterval = typeof mergedOpts.refetchInterval === "function" ? mergedOpts.refetchInterval() : mergedOpts.refetchInterval;
+    if (refetchInterval && refetchInterval > 0) {
+      intervalTimer = setInterval(() => {
+        if (focusManager2.isFocused() || mergedOpts.refetchIntervalInBackground) {
+          targetQuery.fetch(mergedOpts).catch(() => {});
+        }
+      }, refetchInterval);
+    }
+    if (isEnabled) {
+      untrack2(() => {
+        if (targetQuery.isStale(mergedOpts.staleTime) && targetQuery.fetchStatus() === "idle") {
+          const fetchPromise = targetQuery.fetch(mergedOpts);
+          fetchPromise.catch(() => {});
+          const suspense = useContext2(SuspenseContext2);
+          if (suspense) {
+            suspense.registerPromise(fetchPromise);
+          }
+        }
+      });
+    }
+  });
+  onCleanup2(() => {
+    clearIntervalTimer();
+    if (currentQuery() && activeObserver) {
+      currentQuery().removeObserver(activeObserver);
+    }
+  });
+  const data = computed2(() => {
+    version();
+    const q = currentQuery();
+    const rawOpts = resolveOptions();
+    const rawData = q?.data();
+    if (rawData !== undefined) {
+      if (rawOpts.select) {
+        return rawOpts.select(rawData);
+      }
+      return rawData;
+    }
+    if (rawOpts.placeholderData !== undefined) {
+      return typeof rawOpts.placeholderData === "function" ? rawOpts.placeholderData(undefined) : rawOpts.placeholderData;
+    }
+    return;
+  });
+  const error = computed2(() => {
+    version();
+    return currentQuery()?.error() ?? null;
+  });
+  const status = computed2(() => {
+    version();
+    return currentQuery()?.status() ?? "pending";
+  });
+  const fetchStatus = computed2(() => {
+    version();
+    return currentQuery()?.fetchStatus() ?? "idle";
+  });
+  const isLoading = computed2(() => {
+    return status() === "pending" && fetchStatus() === "fetching";
+  });
+  const isFetching = computed2(() => {
+    return fetchStatus() === "fetching";
+  });
+  const isSuccess = computed2(() => {
+    return status() === "success";
+  });
+  const isError = computed2(() => {
+    return status() === "error";
+  });
+  const isStale = computed2(() => {
+    version();
+    const q = currentQuery();
+    const rawOpts = resolveOptions();
+    return q?.isStale(rawOpts.staleTime) ?? true;
+  });
+  const dataUpdatedAt = computed2(() => {
+    version();
+    return currentQuery()?.dataUpdatedAt() ?? 0;
+  });
+  const errorUpdatedAt = computed2(() => {
+    version();
+    return currentQuery()?.errorUpdatedAt() ?? 0;
+  });
+  const refetch = async (refetchOpts) => {
+    const q = untrack2(() => currentQuery());
+    if (!q)
+      return;
+    const rawOpts = resolveOptions();
+    const defaults = queryClient.getDefaultOptions().queries ?? {};
+    const mergedOpts = { ...defaults, ...rawOpts };
+    const rawResult = await q.fetch(mergedOpts, { cancelRefetch: refetchOpts?.cancelRefetch });
+    if (rawOpts.select) {
+      return rawOpts.select(rawResult);
+    }
+    return rawResult;
+  };
+  const accessor = () => {
+    const q = currentQuery();
+    const rawOpts = resolveOptions();
+    if ((rawOpts.suspense || status() === "pending") && q?.promise) {
+      const suspense = useContext2(SuspenseContext2);
+      if (suspense) {
+        suspense.registerPromise(q.promise);
+      }
+    }
+    return data();
+  };
+  Object.defineProperties(accessor, {
+    [SIGNAL_BRAND2]: { value: true },
+    [COMPUTED_BRAND2]: { value: true },
+    value: { get: () => data() },
+    data: { get: () => data },
+    error: { get: () => error },
+    status: { get: () => status },
+    fetchStatus: { get: () => fetchStatus },
+    isLoading: { get: () => isLoading },
+    isFetching: { get: () => isFetching },
+    isSuccess: { get: () => isSuccess },
+    isError: { get: () => isError },
+    isStale: { get: () => isStale },
+    dataUpdatedAt: { get: () => dataUpdatedAt },
+    errorUpdatedAt: { get: () => errorUpdatedAt },
+    refetch: { value: refetch }
+  });
+  return accessor;
+}
+function createInfiniteQuery2(options, client) {
+  const queryClient = useQueryClient2(client);
+  const resolveOptions = () => typeof options === "function" ? options() : options;
+  const isFetchingNextPage = signal2(false);
+  const isFetchingPreviousPage = signal2(false);
+  const baseQuery = createQuery2(() => {
+    const rawOpts = resolveOptions();
+    return {
+      ...rawOpts,
+      queryFn: async (ctx) => {
+        const pageParam = ctx.pageParam ?? rawOpts.initialPageParam;
+        const page = await rawOpts.queryFn({
+          ...ctx,
+          pageParam
+        });
+        return {
+          pages: [page],
+          pageParams: [pageParam]
+        };
+      },
+      select: undefined
+    };
+  }, queryClient);
+  const hasNextPage = computed2(() => {
+    const current = baseQuery.data();
+    if (!current || current.pages.length === 0)
+      return false;
+    const rawOpts = resolveOptions();
+    const lastPage = current.pages[current.pages.length - 1];
+    const lastParam = current.pageParams[current.pageParams.length - 1];
+    const nextParam = rawOpts.getNextPageParam(lastPage, current.pages, lastParam, current.pageParams);
+    return nextParam !== undefined && nextParam !== null;
+  });
+  const hasPreviousPage = computed2(() => {
+    const current = baseQuery.data();
+    if (!current || current.pages.length === 0)
+      return false;
+    const rawOpts = resolveOptions();
+    if (!rawOpts.getPreviousPageParam)
+      return false;
+    const firstPage = current.pages[0];
+    const firstParam = current.pageParams[0];
+    const prevParam = rawOpts.getPreviousPageParam(firstPage, current.pages, firstParam, current.pageParams);
+    return prevParam !== undefined && prevParam !== null;
+  });
+  const fetchNextPage = async () => {
+    const current = baseQuery.data();
+    if (!current || current.pages.length === 0)
+      return;
+    const rawOpts = resolveOptions();
+    const lastPage = current.pages[current.pages.length - 1];
+    const lastParam = current.pageParams[current.pageParams.length - 1];
+    const nextParam = rawOpts.getNextPageParam(lastPage, current.pages, lastParam, current.pageParams);
+    if (nextParam === undefined || nextParam === null) {
+      return current;
+    }
+    isFetchingNextPage.set(true);
+    try {
+      const newPage = await rawOpts.queryFn({
+        queryKey: rawOpts.queryKey,
+        signal: new AbortController().signal,
+        pageParam: nextParam,
+        meta: rawOpts.meta
+      });
+      const nextData = {
+        pages: [...current.pages, newPage],
+        pageParams: [...current.pageParams, nextParam]
+      };
+      queryClient.setQueryData(rawOpts.queryKey, nextData);
+      return nextData;
+    } finally {
+      isFetchingNextPage.set(false);
+    }
+  };
+  const fetchPreviousPage = async () => {
+    const current = baseQuery.data();
+    if (!current || current.pages.length === 0)
+      return;
+    const rawOpts = resolveOptions();
+    if (!rawOpts.getPreviousPageParam)
+      return current;
+    const firstPage = current.pages[0];
+    const firstParam = current.pageParams[0];
+    const prevParam = rawOpts.getPreviousPageParam(firstPage, current.pages, firstParam, current.pageParams);
+    if (prevParam === undefined || prevParam === null) {
+      return current;
+    }
+    isFetchingPreviousPage.set(true);
+    try {
+      const newPage = await rawOpts.queryFn({
+        queryKey: rawOpts.queryKey,
+        signal: new AbortController().signal,
+        pageParam: prevParam,
+        meta: rawOpts.meta
+      });
+      const nextData = {
+        pages: [newPage, ...current.pages],
+        pageParams: [prevParam, ...current.pageParams]
+      };
+      queryClient.setQueryData(rawOpts.queryKey, nextData);
+      return nextData;
+    } finally {
+      isFetchingPreviousPage.set(false);
+    }
+  };
+  const accessor = () => {
+    return baseQuery();
+  };
+  Object.defineProperties(accessor, {
+    [SIGNAL_BRAND2]: { value: true },
+    [COMPUTED_BRAND2]: { value: true },
+    value: { get: () => baseQuery.data() },
+    data: { get: () => baseQuery.data },
+    error: { get: () => baseQuery.error },
+    status: { get: () => baseQuery.status },
+    fetchStatus: { get: () => baseQuery.fetchStatus },
+    isLoading: { get: () => baseQuery.isLoading },
+    isFetching: { get: () => baseQuery.isFetching },
+    isSuccess: { get: () => baseQuery.isSuccess },
+    isError: { get: () => baseQuery.isError },
+    isStale: { get: () => baseQuery.isStale },
+    dataUpdatedAt: { get: () => baseQuery.dataUpdatedAt },
+    errorUpdatedAt: { get: () => baseQuery.errorUpdatedAt },
+    refetch: { value: baseQuery.refetch },
+    fetchNextPage: { value: fetchNextPage },
+    fetchPreviousPage: { value: fetchPreviousPage },
+    hasNextPage: { get: () => hasNextPage },
+    hasPreviousPage: { get: () => hasPreviousPage },
+    isFetchingNextPage: { get: () => isFetchingNextPage },
+    isFetchingPreviousPage: { get: () => isFetchingPreviousPage }
+  });
+  return accessor;
+}
+
+export { FocusManager2, focusManager2, Mutation2, MutationCache2, OnlineManager2, onlineManager2, isPlainObject2, hashKey2, deepEqual2, partialDeepEqual2, matchQuery2, sleep2, Query2, QueryCache2, QueryClient2, QueryClientContext2, QueryClientProvider2, useQueryClient2, createMutation2, createQuery2, createInfiniteQuery2 };