@wow-two-beta/ui-vue 0.0.2

package/dist/query/index.js

@@ -0,0 +1,461 @@
+import { QueryClient, MutationCache, QueryCache, CancelledError, VUE_QUERY_CLIENT, useQuery, useInfiniteQuery, useQueryClient, useMutation, useQueries, keepPreviousData, useIsFetching, useIsMutating, hydrate, dehydrate } from "@tanstack/vue-query";
+import { i as isAbortError } from "../chunks/ErrorRecognizers-oTklha6D.js";
+import { DefaultRetryPolicy, computeRetryDelay, shouldRetry } from "../foundation/resilience/index.js";
+import { g as getErrorMessage } from "../chunks/ErrorMessage-Cqt7WaFn.js";
+import { A as ApiError } from "../chunks/ApiError-l0YdcqqV.js";
+import { q } from "../chunks/QueryPlugin-CfotNm6j.js";
+import { defineComponent, provide, onMounted, onUnmounted, renderSlot, toValue, computed, shallowRef, onScopeDispose, watch, openBlock, createBlock, resolveDynamicComponent, createCommentVNode } from "vue";
+import { u as useNavigationProgress } from "../chunks/UseNavigationProgress-TQIkkXyU.js";
+function toApiError(error) {
+  if (error instanceof ApiError) return error;
+  return new ApiError(0, null, getErrorMessage(error, "Unknown error"));
+}
+const StaleTimeMs = 3e4;
+const GcTimeMs = 5 * 6e4;
+function isCancellation(error) {
+  return error instanceof CancelledError || isAbortError(error);
+}
+function createQueryClient(options = {}) {
+  const handleError = (error, meta) => {
+    if (isCancellation(error)) return;
+    if (meta?.suppressGlobalError === true) return;
+    options.onError?.(toApiError(error), { meta });
+  };
+  const policy = options.retry ?? DefaultRetryPolicy;
+  return new QueryClient({
+    queryCache: new QueryCache({ onError: (error, query) => handleError(error, query.meta) }),
+    mutationCache: new MutationCache({
+      onError: (error, _variables, _context, mutation) => handleError(error, mutation.meta)
+    }),
+    defaultOptions: {
+      queries: {
+        staleTime: StaleTimeMs,
+        gcTime: GcTimeMs,
+        refetchOnWindowFocus: false,
+        retry: (failureCount, error) => !isCancellation(error) && shouldRetry(policy, failureCount, toApiError(error).status),
+        retryDelay: (attemptIndex) => computeRetryDelay(policy, attemptIndex + 1)
+      },
+      mutations: { retry: 0 }
+    }
+  });
+}
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  ...{ name: "QueryProvider" },
+  __name: "QueryProvider",
+  props: {
+    client: {}
+  },
+  setup(__props) {
+    const props = __props;
+    provide(VUE_QUERY_CLIENT, props.client);
+    onMounted(() => props.client.mount());
+    onUnmounted(() => props.client.unmount());
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+function defineEndpoint(endpoint) {
+  return endpoint;
+}
+function useAppQuery({
+  key,
+  queryFn,
+  map,
+  enabled,
+  meta
+}) {
+  const query = useQuery(() => ({
+    queryKey: toValue(key),
+    queryFn: ({ signal }) => queryFn({ signal }),
+    select: map ?? ((raw) => raw),
+    enabled: toValue(enabled),
+    meta
+  }));
+  return {
+    data: query.data,
+    loading: computed(() => query.isPending.value && query.isFetching.value),
+    error: computed(() => query.error.value ? toApiError(query.error.value) : null),
+    refetch: query.refetch
+  };
+}
+function useAppInfiniteQuery({
+  key,
+  queryFn,
+  getNextPageParam,
+  initialPageParam,
+  mapPage,
+  refetchInterval,
+  enabled,
+  meta
+}) {
+  const extract = (page) => mapPage ? mapPage(page) : page;
+  const query = useInfiniteQuery(() => ({
+    queryKey: toValue(key),
+    queryFn: ({ pageParam, signal }) => queryFn({ pageParam, signal }),
+    getNextPageParam,
+    initialPageParam,
+    enabled: toValue(enabled),
+    meta,
+    refetchInterval: refetchInterval === void 0 ? void 0 : (query_) => {
+      if (typeof refetchInterval === "number") return refetchInterval;
+      const current = (query_.state.data?.pages ?? []).flatMap((page) => [...extract(page)]);
+      return refetchInterval(current);
+    }
+  }));
+  return {
+    items: computed(() => (query.data.value?.pages ?? []).flatMap((page) => [...extract(page)])),
+    loading: computed(() => query.isPending.value && query.isFetching.value),
+    error: computed(() => query.error.value ? toApiError(query.error.value) : null),
+    hasNextPage: query.hasNextPage,
+    fetchNextPage: query.fetchNextPage,
+    isFetchingNextPage: query.isFetchingNextPage,
+    refetch: query.refetch
+  };
+}
+function useAppMutation({
+  mutationFn,
+  invalidates,
+  onConfirmed,
+  meta
+}) {
+  const queryClient = useQueryClient();
+  const mutation = useMutation({
+    mutationFn,
+    meta,
+    onSuccess: async (data, vars) => {
+      const keys = invalidates?.(vars, data) ?? [];
+      await Promise.all(keys.map((queryKey) => queryClient.invalidateQueries({ queryKey })));
+      onConfirmed?.(data, vars, queryClient);
+    }
+  });
+  return {
+    mutate: mutation.mutate,
+    mutateAsync: mutation.mutateAsync,
+    data: mutation.data,
+    loading: mutation.isPending,
+    error: computed(() => mutation.error.value ? toApiError(mutation.error.value) : null),
+    reset: mutation.reset
+  };
+}
+function resolveKey(key) {
+  return "queryFn" in key ? key.key : key;
+}
+function useOptimisticMutation({
+  mutationFn,
+  targets,
+  invalidateOnSettle = true
+}) {
+  const queryClient = useQueryClient();
+  const mutation = useMutation({
+    mutationFn,
+    onMutate: async (vars) => {
+      await Promise.all(
+        targets.map((target) => queryClient.cancelQueries({ queryKey: resolveKey(target.key) }))
+      );
+      return targets.map((target) => {
+        const queryKey = resolveKey(target.key);
+        const previous = queryClient.getQueryData(queryKey);
+        queryClient.setQueryData(queryKey, () => target.apply(previous, vars));
+        return { queryKey, previous };
+      });
+    },
+    onError: (_error, _vars, snapshots) => {
+      for (const { queryKey, previous } of snapshots ?? []) {
+        if (previous === void 0) queryClient.removeQueries({ queryKey, exact: true });
+        else queryClient.setQueryData(queryKey, () => previous);
+      }
+    },
+    onSettled: async () => {
+      if (!invalidateOnSettle) return;
+      await Promise.all(
+        targets.map((target) => queryClient.invalidateQueries({ queryKey: resolveKey(target.key) }))
+      );
+    }
+  });
+  return {
+    mutate: mutation.mutate,
+    mutateAsync: mutation.mutateAsync,
+    data: mutation.data,
+    loading: mutation.isPending,
+    error: computed(() => mutation.error.value ? toApiError(mutation.error.value) : null),
+    reset: mutation.reset
+  };
+}
+function useAppQueries({
+  queries,
+  enabled
+}) {
+  const results = useQueries({
+    queries: computed(
+      () => toValue(queries).map((entry) => ({
+        queryKey: entry.key,
+        queryFn: ({ signal }) => entry.queryFn({ signal }),
+        select: entry.map ?? ((raw) => raw),
+        enabled: toValue(enabled)
+      }))
+    )
+  });
+  const mapped = computed(
+    () => results.value.map((query) => ({
+      data: query.data,
+      loading: query.isPending && query.isFetching,
+      error: query.error ? toApiError(query.error) : null
+    }))
+  );
+  return {
+    results: mapped,
+    data: computed(() => mapped.value.map((result) => result.data)),
+    loading: computed(() => mapped.value.some((result) => result.loading)),
+    errors: computed(() => mapped.value.flatMap((result) => result.error ? [result.error] : []))
+  };
+}
+function useAppPaginatedQuery({
+  key,
+  queryFn,
+  page,
+  mapPage,
+  enabled,
+  meta
+}) {
+  const query = useQuery(() => ({
+    queryKey: [...toValue(key), toValue(page)],
+    queryFn: ({ signal }) => queryFn({ page: toValue(page), signal }),
+    placeholderData: keepPreviousData,
+    enabled: toValue(enabled),
+    meta
+  }));
+  const items = computed(() => {
+    const data = query.data.value;
+    if (data === void 0) return [];
+    return mapPage ? mapPage(data) : data;
+  });
+  return {
+    items,
+    page: query.data,
+    loading: computed(() => query.isPending.value && query.isFetching.value),
+    error: computed(() => query.error.value ? toApiError(query.error.value) : null),
+    isPlaceholder: query.isPlaceholderData,
+    refetch: query.refetch
+  };
+}
+function byPageToken() {
+  return (lastPage) => lastPage.nextPageToken;
+}
+function pageItems(page) {
+  return page.items;
+}
+function useAppLazyQuery({
+  key,
+  queryFn,
+  map,
+  meta
+}) {
+  const client = useQueryClient();
+  const data = shallowRef(void 0);
+  const loading = shallowRef(false);
+  const error = shallowRef(null);
+  let sequence = 0;
+  const fetch = async () => {
+    const current = ++sequence;
+    loading.value = true;
+    error.value = null;
+    try {
+      const raw = await client.fetchQuery({
+        queryKey: toValue(key),
+        queryFn: ({ signal }) => queryFn({ signal }),
+        meta
+      });
+      const mapped = map ? map(raw) : raw;
+      if (current === sequence) {
+        data.value = mapped;
+        loading.value = false;
+      }
+      return mapped;
+    } catch (caught) {
+      if (current === sequence) {
+        error.value = toApiError(caught);
+        loading.value = false;
+      }
+      throw caught;
+    }
+  };
+  const reset = () => {
+    sequence += 1;
+    data.value = void 0;
+    error.value = null;
+    loading.value = false;
+  };
+  return { data, loading, error, fetch, reset };
+}
+function useQueryCache() {
+  const client = useQueryClient();
+  return {
+    get: (key) => client.getQueryData(key),
+    set: (key, data) => {
+      client.setQueryData(key, data);
+    },
+    invalidate: (key) => client.invalidateQueries({ queryKey: key }),
+    remove: (key) => {
+      client.removeQueries({ queryKey: key });
+    },
+    prefetch: ({ key, queryFn }) => client.prefetchQuery({ queryKey: key, queryFn: ({ signal }) => queryFn({ signal }) })
+  };
+}
+let activeClient;
+function warm(client, { key, queryFn }) {
+  void client.prefetchQuery({ queryKey: key, queryFn });
+}
+function usePrefetchQuery() {
+  const client = useQueryClient();
+  activeClient = client;
+  onScopeDispose(() => {
+    if (activeClient === client) activeClient = void 0;
+  });
+  return (target) => warm(client, target);
+}
+function prefetchProps(target) {
+  const run = () => {
+    if (activeClient) warm(activeClient, target);
+  };
+  return { onMouseenter: run, onFocus: run };
+}
+async function useAppSuspenseQuery({
+  key,
+  queryFn,
+  map,
+  meta
+}) {
+  const query = useQuery(() => ({
+    queryKey: toValue(key),
+    queryFn: ({ signal }) => queryFn({ signal }),
+    select: map,
+    meta
+  }));
+  const result = await query.suspense();
+  if (result.error) throw result.error;
+  return { data: query.data, refetch: query.refetch };
+}
+function useQueryProgressBridge() {
+  const fetching = useIsFetching();
+  const mutating = useIsMutating();
+  const { begin } = useNavigationProgress();
+  let end = null;
+  watch(
+    () => fetching.value + mutating.value,
+    (activity) => {
+      if (activity > 0 && end === null) end = begin();
+      else if (activity === 0 && end !== null) {
+        end();
+        end = null;
+      }
+    },
+    { immediate: true }
+  );
+  onScopeDispose(() => {
+    end?.();
+    end = null;
+  });
+}
+const QueryProgressBridge = defineComponent({
+  name: "QueryProgressBridge",
+  setup() {
+    useQueryProgressBridge();
+    return () => null;
+  }
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ name: "QueryDevtools" },
+  __name: "Devtools",
+  props: {
+    initialIsOpen: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const devtools = shallowRef(null);
+    onMounted(async () => {
+      return;
+    });
+    return (_ctx, _cache) => {
+      return devtools.value ? (openBlock(), createBlock(resolveDynamicComponent(devtools.value), {
+        key: 0,
+        "initial-is-open": props.initialIsOpen
+      }, null, 8, ["initial-is-open"])) : createCommentVNode("", true);
+    };
+  }
+});
+const DefaultStorageKey = "app:query-cache";
+const DefaultMaxAgeMs = 24 * 60 * 6e4;
+const WriteThrottleMs = 1e3;
+function setupQueryPersistence(client, options = {}) {
+  if (typeof window === "undefined") return null;
+  const { storageKey = DefaultStorageKey, maxAgeMs = DefaultMaxAgeMs, buster = "" } = options;
+  restore(client, storageKey, maxAgeMs, buster);
+  let timer = null;
+  const schedule = () => {
+    if (timer !== null) return;
+    timer = setTimeout(() => {
+      timer = null;
+      write(client, storageKey, buster);
+    }, WriteThrottleMs);
+  };
+  const unsubscribeQueries = client.getQueryCache().subscribe(schedule);
+  const unsubscribeMutations = client.getMutationCache().subscribe(schedule);
+  return {
+    unsubscribe: () => {
+      unsubscribeQueries();
+      unsubscribeMutations();
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    },
+    restored: Promise.resolve()
+  };
+}
+function restore(client, storageKey, maxAgeMs, buster) {
+  try {
+    const raw = window.localStorage.getItem(storageKey);
+    if (!raw) return;
+    const snapshot = JSON.parse(raw);
+    const isStale = Date.now() - snapshot.timestamp > maxAgeMs;
+    if (snapshot.buster !== buster || isStale) {
+      window.localStorage.removeItem(storageKey);
+      return;
+    }
+    hydrate(client, snapshot.state);
+  } catch {
+  }
+}
+function write(client, storageKey, buster) {
+  try {
+    const snapshot = { buster, timestamp: Date.now(), state: dehydrate(client) };
+    window.localStorage.setItem(storageKey, JSON.stringify(snapshot));
+  } catch {
+  }
+}
+export {
+  _sfc_main as QueryDevtools,
+  QueryProgressBridge,
+  _sfc_main$1 as QueryProvider,
+  byPageToken,
+  createQueryClient,
+  defineEndpoint,
+  pageItems,
+  prefetchProps,
+  q as queryPlugin,
+  setupQueryPersistence,
+  toApiError,
+  useAppInfiniteQuery,
+  useAppLazyQuery,
+  useAppMutation,
+  useAppPaginatedQuery,
+  useAppQueries,
+  useAppQuery,
+  useAppSuspenseQuery,
+  useOptimisticMutation,
+  usePrefetchQuery,
+  useQueryCache,
+  useQueryProgressBridge
+};
+//# sourceMappingURL=index.js.map

package/dist/query/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../src/query/ToApiError.ts","../../src/query/CreateQueryClient.ts","../../src/query/QueryProvider.vue","../../src/query/Endpoints.ts","../../src/query/UseAppQuery.ts","../../src/query/UseAppInfiniteQuery.ts","../../src/query/UseAppMutation.ts","../../src/query/UseOptimisticMutation.ts","../../src/query/UseAppQueries.ts","../../src/query/UseAppPaginatedQuery.ts","../../src/query/PageHelpers.ts","../../src/query/UseAppLazyQuery.ts","../../src/query/UseQueryCache.ts","../../src/query/UsePrefetchQuery.ts","../../src/query/UseAppSuspenseQuery.ts","../../src/query/QueryProgressBridge.ts","../../src/query/Devtools.vue","../../src/query/Persistence.ts"],"sourcesContent":["import { getErrorMessage } from '../foundation/errors';\nimport { ApiError } from '../foundation/http';\n\n/**\n * Coerces any thrown value into the SDK `ApiError` — passes through an `ApiError`, wraps everything\n * else as status `0` (network / unknown) with the message `getErrorMessage` reads off it, so an\n * `Error` from another realm (iframe · worker) keeps its message instead of failing `instanceof`.\n */\nexport function toApiError(error: unknown): ApiError {\n  if (error instanceof ApiError) return error;\n  return new ApiError(0, null, getErrorMessage(error, 'Unknown error'));\n}\n","import { CancelledError, MutationCache, QueryCache, QueryClient } from '@tanstack/vue-query';\n\nimport { isAbortError } from '../foundation/errors';\nimport type { ApiError } from '../foundation/http';\n\nimport { computeRetryDelay, DefaultRetryPolicy, shouldRetry, type RetryPolicy } from '../foundation/resilience';\n\nimport { toApiError } from './ToApiError';\n\nconst StaleTimeMs = 30_000;\nconst GcTimeMs = 5 * 60_000;\n\n/**\n * Checks for a cancellation — TanStack's own `CancelledError`, or the native `AbortError` a queryFn\n * rethrows when its signal aborts outside the library (the transport client deliberately never wraps\n * aborts). A cancellation is intent, not failure: it must neither retry (`toApiError` maps it to\n * status `0`, which the transient set would otherwise retry) nor reach the global `onError` toast.\n */\nfunction isCancellation(error: unknown): boolean {\n  return error instanceof CancelledError || isAbortError(error);\n}\n\n/** The metadata bag a hook's `meta` option attaches to its query/mutation — free-form keys, read back by the global error seam. `suppressGlobalError: true` keeps that call's failures out of the global `onError` (per-query opt-out for polling / boundary-handled errors). */\nexport type AppQueryMeta = Record<string, unknown>;\n\n/** Carries the failing query's / mutation's context into the global `onError`. */\nexport interface QueryErrorContext {\n  /** The `meta` attached at the call site, or `undefined` when none was set. */\n  readonly meta: AppQueryMeta | undefined;\n}\n\n/** Defines options for `createQueryClient`. */\nexport interface CreateQueryClientOptions {\n  /** Emits a coerced `ApiError` whenever any query or mutation fails — wire a toast here (`feedbackQueryErrors()` from `/feedback` fits directly). Cancellations and calls whose `meta` sets `suppressGlobalError: true` are skipped; `context.meta` carries the call's `meta` for app-side filtering. */\n  readonly onError?: (error: ApiError, context: QueryErrorContext) => void;\n\n  /** The retry policy for transient query failures (backoff · jitter · retryable statuses). Default `DefaultRetryPolicy`. Mutations never retry; `onRetry` is transport-level only — the TanStack retry seam has no pre-retry hook, so it is not invoked here. */\n  readonly retry?: RetryPolicy;\n}\n\n/** Creates the app `QueryClient` — house defaults (30s stale · 5m gc · no focus-refetch · mutations no-retry) + a configurable `RetryPolicy` + global error coercion to `ApiError`. */\nexport function createQueryClient(options: CreateQueryClientOptions = {}): QueryClient {\n  const handleError = (error: unknown, meta: AppQueryMeta | undefined): void => {\n    if (isCancellation(error)) return;\n    if (meta?.suppressGlobalError === true) return;\n    options.onError?.(toApiError(error), { meta });\n  };\n  const policy = options.retry ?? DefaultRetryPolicy;\n\n  return new QueryClient({\n    queryCache: new QueryCache({ onError: (error, query) => handleError(error, query.meta) }),\n    mutationCache: new MutationCache({\n      onError: (error, _variables, _context, mutation) => handleError(error, mutation.meta),\n    }),\n    defaultOptions: {\n      queries: {\n        staleTime: StaleTimeMs,\n        gcTime: GcTimeMs,\n        refetchOnWindowFocus: false,\n        retry: (failureCount, error) =>\n          !isCancellation(error) && shouldRetry(policy, failureCount, toApiError(error).status),\n        retryDelay: (attemptIndex) => computeRetryDelay(policy, attemptIndex + 1),\n      },\n      mutations: { retry: 0 },\n    },\n  });\n}\n","<script lang=\"ts\">\nimport type { QueryClient } from '@tanstack/vue-query';\n\n/** Defines the props for {@link QueryProvider}. */\nexport interface QueryProviderProps {\n  /** The app `QueryClient` (from `createQueryClient`). */\n  client: QueryClient;\n}\n</script>\n\n<script setup lang=\"ts\">\nimport { onMounted, onUnmounted, provide } from 'vue';\n// `QueryClient` is already imported as a TYPE by the plain `<script>` block above — the two blocks\n// compile into ONE module, so only the injection-key VALUE comes in here.\nimport { VUE_QUERY_CLIENT } from '@tanstack/vue-query';\n\n/**\n * Mounts the app `QueryClient` above its subtree.\n *\n * `@tanstack/vue-query` ships no `QueryClientProvider` component — it installs as an app plugin\n * (`queryPlugin`). This is the component form React had, rebuilt on the same injection key the\n * library's own `useQueryClient()` reads, so every hook in this module works underneath it. Use it\n * when a SUBTREE (or a test) needs its own client; use `queryPlugin` for the whole app.\n *\n * `client.mount()` runs from `onMounted`, which never executes on the server — the plugin skips it\n * there for the same reason: mounting subscribes the focus / online managers to browser globals.\n *\n * Renders no element of its own — the slot passes straight through.\n */\ndefineOptions({ name: 'QueryProvider' });\n\ndefineSlots<{\n  /** The subtree with access to the client. */\n  default(): unknown;\n}>();\n\nconst props = defineProps<QueryProviderProps>();\n\nprovide(VUE_QUERY_CLIENT, props.client);\n\nonMounted(() => props.client.mount());\nonUnmounted(() => props.client.unmount());\n</script>\n\n<template>\n  <slot />\n</template>\n","// Typed endpoint definitions — the generic core of a query-factory registry (the data-layer\n// `definePath`). An app declares per-resource factories over `defineEndpoint`\n// (`const codesApi = { list: (q?: string) => defineEndpoint({ key: …, queryFn: … }) }`); this module\n// owns only the typing core — key + fetcher declared once, together, so the pairing can never desync.\n// A def is a plain `{ key, queryFn }`: it spreads into `useAppQuery` / `useAppSuspenseQuery` /\n// `useAppLazyQuery`, feeds `usePrefetchQuery` / `prefetchProps` / `useQueryCache().prefetch` whole,\n// and pairs with a bare `QueryClient` (`fetchQuery({ queryKey: def.key, queryFn: def.queryFn })`).\n// Mutations stay plain client calls into `useAppMutation` — no def shape for writes (an\n// `useOptimisticMutation` target may reuse a def's `key` to locate the cached read it patches).\n\nimport type { QueryKey } from '@tanstack/vue-query';\n\n/** Defines a typed endpoint — a query key fused with the fetcher that fills it. */\nexport interface Endpoint<TRaw> {\n  /** The query key this endpoint caches under — the same key every consuming surface reads. */\n  readonly key: QueryKey;\n\n  /** Fetches the raw payload; receives the abort signal so the request cancels with the query. */\n  readonly queryFn: (context: { signal: AbortSignal }) => Promise<TRaw>;\n}\n\n/** Defines a parameterized endpoint factory — call with the endpoint's args for a def keyed to them. */\nexport type EndpointFn<TArgs extends readonly unknown[], TRaw> = (...args: TArgs) => Endpoint<TRaw>;\n\n/** Creates a typed endpoint definition — constrains the shape, infers `TRaw` from the fetcher, and returns the def unchanged (pure typing; deleting the call leaves valid code). */\nexport function defineEndpoint<TRaw>(endpoint: Endpoint<TRaw>): Endpoint<TRaw> {\n  return endpoint;\n}\n","import { computed, toValue, type ComputedRef, type MaybeRefOrGetter, type Ref } from 'vue';\nimport { useQuery, type QueryKey } from '@tanstack/vue-query';\n\nimport type { ApiError } from '../foundation/http';\n\nimport type { AppQueryMeta } from './CreateQueryClient';\nimport { toApiError } from './ToApiError';\n\n/** Defines options for `useAppQuery` — `TRaw` first so it infers from `queryFn` (a spread def) and `TData` defaults to it when `map` is absent. */\nexport interface UseAppQueryOptions<TRaw, TData = TRaw> {\n  /** The cache key (from `queryKeys`). A ref or getter re-keys the query reactively — React re-ran the hook instead. */\n  readonly key: MaybeRefOrGetter<QueryKey>;\n\n  /** Fetches the raw payload; receives the `AbortSignal` so the request cancels on unmount. */\n  readonly queryFn: (ctx: { signal: AbortSignal }) => Promise<TRaw>;\n\n  /** Maps the raw payload to the domain shape — identity when omitted. */\n  readonly map?: (raw: TRaw) => TData;\n\n  /** Gates the query — skips fetching while `false`. A ref or getter toggles it reactively. */\n  readonly enabled?: MaybeRefOrGetter<boolean>;\n\n  /** Metadata surfaced to the global `onError` seam — `suppressGlobalError: true` keeps this query's failures out of it. */\n  readonly meta?: AppQueryMeta;\n}\n\n/** Represents a single-resource query's slice — every member reactive. */\nexport interface UseAppQueryReturn<TData> {\n  /** The mapped domain payload, or `undefined` until it resolves. */\n  readonly data: Ref<TData | undefined>;\n\n  /** True while there is no data yet and a fetch is in flight. */\n  readonly loading: ComputedRef<boolean>;\n\n  /** The failure coerced to `ApiError`, or `null`. */\n  readonly error: ComputedRef<ApiError | null>;\n\n  /** Refetches the query. */\n  readonly refetch: () => unknown;\n}\n\n/**\n * Manages a single-resource query — wraps `useQuery`, maps raw→domain via `select`, and coerces\n * failures to `ApiError`.\n *\n * Returns REFS, not values: `@tanstack/vue-query` hands back a ref per field, and a composable that\n * unwrapped them would freeze at the first render. Read `data.value` (or bind `data` in a template).\n */\nexport function useAppQuery<TRaw, TData = TRaw>({\n  key,\n  queryFn,\n  map,\n  enabled,\n  meta,\n}: UseAppQueryOptions<TRaw, TData>): UseAppQueryReturn<TData> {\n  // A getter for the WHOLE options object: `key` and `enabled` are `MaybeRefOrGetter`, and this is\n  // the one form that re-evaluates every one of them together on each dependency change.\n  const query = useQuery<TRaw, Error, TData, QueryKey>(() => ({\n    queryKey: toValue(key),\n    queryFn: ({ signal }) => queryFn({ signal }),\n    select: map ?? ((raw: TRaw) => raw as unknown as TData),\n    enabled: toValue(enabled),\n    meta,\n  }));\n\n  return {\n    data: query.data,\n    loading: computed(() => query.isPending.value && query.isFetching.value),\n    error: computed(() => (query.error.value ? toApiError(query.error.value) : null)),\n    refetch: query.refetch,\n  };\n}\n","import { computed, toValue, type ComputedRef, type MaybeRefOrGetter, type Ref } from 'vue';\nimport { useInfiniteQuery, type InfiniteData, type QueryKey } from '@tanstack/vue-query';\n\nimport type { ApiError } from '../foundation/http';\n\nimport type { AppQueryMeta } from './CreateQueryClient';\nimport { toApiError } from './ToApiError';\n\n/** Defines options for `useAppInfiniteQuery`. */\nexport interface UseAppInfiniteQueryOptions<TItem, TPage> {\n  /** The cache key (from `queryKeys`). */\n  readonly key: MaybeRefOrGetter<QueryKey>;\n\n  /** Fetches one page for `pageParam`; receives the `AbortSignal`. */\n  readonly queryFn: (ctx: { pageParam: unknown; signal: AbortSignal }) => Promise<TPage>;\n\n  /** Derives the next page's param from the last page — return `undefined`/`null` to stop. */\n  readonly getNextPageParam: (lastPage: TPage, allPages: readonly TPage[]) => unknown;\n\n  /** The param for the first page. */\n  readonly initialPageParam: unknown;\n\n  /** Extracts items from a page — the page itself is the item array when omitted. */\n  readonly mapPage?: (page: TPage) => readonly TItem[];\n\n  /** Poll interval in ms, or a fn of the current items → ms / `false` (poll-while-running). */\n  readonly refetchInterval?: number | ((items: readonly TItem[]) => number | false);\n\n  /** Gates the query — skips fetching while `false`. */\n  readonly enabled?: MaybeRefOrGetter<boolean>;\n\n  /** Metadata surfaced to the global `onError` seam — `suppressGlobalError: true` keeps this query's failures out of it (e.g. polls that would otherwise toast per failed refetch). */\n  readonly meta?: AppQueryMeta;\n}\n\n/** Represents an infinite query's slice — every member reactive. */\nexport interface UseAppInfiniteQueryReturn<TItem> {\n  /** Every fetched page flattened to items. */\n  readonly items: ComputedRef<readonly TItem[]>;\n\n  /** True while there is no page yet and a fetch is in flight. */\n  readonly loading: ComputedRef<boolean>;\n\n  /** The failure coerced to `ApiError`, or `null`. */\n  readonly error: ComputedRef<ApiError | null>;\n\n  /** Whether another page can be fetched. */\n  readonly hasNextPage: Ref<boolean>;\n\n  /** Fetches the next page. */\n  readonly fetchNextPage: (...args: never[]) => unknown;\n\n  /** True while the next page is in flight. */\n  readonly isFetchingNextPage: Ref<boolean>;\n\n  /** Refetches every fetched page. */\n  readonly refetch: () => unknown;\n}\n\n/** Manages a paginated resource — wraps `useInfiniteQuery`, flattens pages to items, and supports poll-while-running. */\nexport function useAppInfiniteQuery<TItem, TPage>({\n  key,\n  queryFn,\n  getNextPageParam,\n  initialPageParam,\n  mapPage,\n  refetchInterval,\n  enabled,\n  meta,\n}: UseAppInfiniteQueryOptions<TItem, TPage>): UseAppInfiniteQueryReturn<TItem> {\n  // React memoized this with `useCallback` so the `useMemo` below did not re-run each render; Vue\n  // recomputes only when a tracked dependency changes, so a plain closure is enough.\n  const extract = (page: TPage): readonly TItem[] =>\n    mapPage ? mapPage(page) : (page as unknown as readonly TItem[]);\n\n  const query = useInfiniteQuery<TPage, Error, InfiniteData<TPage, unknown>, QueryKey, unknown>(() => ({\n    queryKey: toValue(key),\n    queryFn: ({ pageParam, signal }) => queryFn({ pageParam, signal }),\n    getNextPageParam,\n    initialPageParam,\n    enabled: toValue(enabled),\n    meta,\n    refetchInterval:\n      refetchInterval === undefined\n        ? undefined\n        : (query_) => {\n            if (typeof refetchInterval === 'number') return refetchInterval;\n            const current = (query_.state.data?.pages ?? []).flatMap((page) => [...extract(page)]);\n            return refetchInterval(current);\n          },\n  }));\n\n  return {\n    items: computed(() => (query.data.value?.pages ?? []).flatMap((page) => [...extract(page)])),\n    loading: computed(() => query.isPending.value && query.isFetching.value),\n    error: computed(() => (query.error.value ? toApiError(query.error.value) : null)),\n    hasNextPage: query.hasNextPage,\n    fetchNextPage: query.fetchNextPage,\n    isFetchingNextPage: query.isFetchingNextPage,\n    refetch: query.refetch,\n  };\n}\n","import { computed, type ComputedRef, type Ref } from 'vue';\nimport { useMutation, useQueryClient, type QueryClient, type QueryKey } from '@tanstack/vue-query';\n\nimport type { ApiError } from '../foundation/http';\n\nimport type { AppQueryMeta } from './CreateQueryClient';\nimport { toApiError } from './ToApiError';\n\n/** Defines options for `useAppMutation`. */\nexport interface UseAppMutationOptions<TData, TVars> {\n  /** Performs the mutation against the backend. */\n  readonly mutationFn: (vars: TVars) => Promise<TData>;\n\n  /** Query keys to invalidate on success — derived from the vars and the server's returned value. */\n  readonly invalidates?: (vars: TVars, data: TData) => readonly QueryKey[];\n\n  /** Reconciles the cache from the server's confirmed result (e.g. `setQueryData`) after invalidation. */\n  readonly onConfirmed?: (data: TData, vars: TVars, queryClient: QueryClient) => void;\n\n  /** Metadata surfaced to the global `onError` seam — `suppressGlobalError: true` keeps this mutation's failures out of it. */\n  readonly meta?: AppQueryMeta;\n}\n\n/** Represents a mutation's slice — state as refs, commands as plain functions. */\nexport interface UseAppMutationReturn<TData, TVars> {\n  /** Fires the mutation, fire-and-forget. */\n  readonly mutate: (vars: TVars) => void;\n\n  /** Fires the mutation and resolves with its result. */\n  readonly mutateAsync: (vars: TVars) => Promise<TData>;\n\n  /** The last successful result. */\n  readonly data: Ref<TData | undefined>;\n\n  /** True while the mutation is in flight. */\n  readonly loading: Ref<boolean>;\n\n  /** The failure coerced to `ApiError`, or `null`. */\n  readonly error: ComputedRef<ApiError | null>;\n\n  /** Clears the mutation back to idle. */\n  readonly reset: () => void;\n}\n\n/** Manages a passive mutation — reconciles the cache only from the backend-confirmed result; no optimistic update, no rollback. */\nexport function useAppMutation<TData, TVars>({\n  mutationFn,\n  invalidates,\n  onConfirmed,\n  meta,\n}: UseAppMutationOptions<TData, TVars>): UseAppMutationReturn<TData, TVars> {\n  const queryClient = useQueryClient();\n\n  const mutation = useMutation<TData, Error, TVars>({\n    mutationFn,\n    meta,\n    onSuccess: async (data, vars) => {\n      const keys = invalidates?.(vars, data) ?? [];\n      await Promise.all(keys.map((queryKey) => queryClient.invalidateQueries({ queryKey })));\n      onConfirmed?.(data, vars, queryClient);\n    },\n  });\n\n  return {\n    mutate: mutation.mutate,\n    mutateAsync: mutation.mutateAsync,\n    data: mutation.data,\n    loading: mutation.isPending,\n    error: computed(() => (mutation.error.value ? toApiError(mutation.error.value) : null)),\n    reset: mutation.reset,\n  };\n}\n","import { computed } from 'vue';\nimport { useMutation, useQueryClient, type QueryKey } from '@tanstack/vue-query';\n\nimport type { Endpoint } from './Endpoints';\nimport { toApiError } from './ToApiError';\nimport type { UseAppMutationReturn } from './UseAppMutation';\n\n/** Defines one cached query an optimistic mutation patches — where it lives and how it changes. */\nexport interface OptimisticTarget<TVars, TCached = unknown> {\n  /** Locates the cached entry to patch — a query key, or an endpoint def (patched at its `key`). */\n  readonly key: QueryKey | Endpoint<TCached>;\n\n  /**\n   * Produces the next cached value from the current one and the mutation vars — pure, no side effects.\n   * `current` is `undefined` when the key holds no data yet; returning a value then seeds the entry\n   * (and rollback removes the seed).\n   */\n  // Method syntax on purpose: its bivariant parameters let targets of different `TCached` shapes\n  // (each annotating its own `current`) share one `targets` array typed `OptimisticTarget<TVars>[]`.\n  apply(current: TCached | undefined, vars: TVars): TCached;\n}\n\n/** Defines options for `useOptimisticMutation`. */\nexport interface UseOptimisticMutationOptions<TData, TVars> {\n  /** Performs the mutation against the backend. */\n  readonly mutationFn: (vars: TVars) => Promise<TData>;\n\n  /** The cached queries this mutation patches — each is cancelled, snapshotted, and applied before the request fires, then rolled back on error. */\n  readonly targets: readonly OptimisticTarget<TVars>[];\n\n  /** Invalidates every target key once the mutation settles (success or error) so the server truth reconciles the patch — `true` when omitted. */\n  readonly invalidateOnSettle?: boolean;\n}\n\n/** A per-target snapshot taken before the patch — the unit of rollback. */\ninterface TargetSnapshot {\n  readonly queryKey: QueryKey;\n  readonly previous: unknown;\n}\n\n/** Resolves a target locator to its query key — unwraps an endpoint def, passes a bare key through. */\nfunction resolveKey(key: QueryKey | Endpoint<unknown>): QueryKey {\n  return 'queryFn' in key ? key.key : key;\n}\n\n/** Manages an optimistic mutation — the canonical TanStack v5 flow in the house shape: cancel + snapshot + patch every target on mutate, roll the patches back on error, reconcile with the server on settle. `useAppMutation` stays the passive default. */\nexport function useOptimisticMutation<TData, TVars>({\n  mutationFn,\n  targets,\n  invalidateOnSettle = true,\n}: UseOptimisticMutationOptions<TData, TVars>): UseAppMutationReturn<TData, TVars> {\n  const queryClient = useQueryClient();\n\n  const mutation = useMutation<TData, Error, TVars, readonly TargetSnapshot[]>({\n    mutationFn,\n    onMutate: async (vars) => {\n      // Cancel in-flight fetches first so a late server response can't clobber the patch.\n      await Promise.all(\n        targets.map((target) => queryClient.cancelQueries({ queryKey: resolveKey(target.key) })),\n      );\n\n      // Snapshot, then patch. A later mutation on the same key snapshots this patch — rollbacks chain.\n      return targets.map((target) => {\n        const queryKey = resolveKey(target.key);\n        const previous = queryClient.getQueryData(queryKey);\n        queryClient.setQueryData(queryKey, () => target.apply(previous, vars));\n        return { queryKey, previous };\n      });\n    },\n    onError: (_error, _vars, snapshots) => {\n      // Restore each target exactly — a seeded entry (no previous) is removed, since `setQueryData(key, undefined)` is ignored.\n      for (const { queryKey, previous } of snapshots ?? []) {\n        if (previous === undefined) queryClient.removeQueries({ queryKey, exact: true });\n        else queryClient.setQueryData(queryKey, () => previous);\n      }\n    },\n    onSettled: async () => {\n      if (!invalidateOnSettle) return;\n      await Promise.all(\n        targets.map((target) => queryClient.invalidateQueries({ queryKey: resolveKey(target.key) })),\n      );\n    },\n  });\n\n  return {\n    mutate: mutation.mutate,\n    mutateAsync: mutation.mutateAsync,\n    data: mutation.data,\n    loading: mutation.isPending,\n    error: computed(() => (mutation.error.value ? toApiError(mutation.error.value) : null)),\n    reset: mutation.reset,\n  };\n}\n","import { computed, toValue, type ComputedRef, type MaybeRefOrGetter, type Ref } from 'vue';\nimport { useQueries, type QueryKey, type QueryObserverResult } from '@tanstack/vue-query';\n\nimport type { ApiError } from '../foundation/http';\n\nimport { toApiError } from './ToApiError';\n\n/** Defines one entry in a parallel `useAppQueries` batch — `TRaw` first so it infers from `queryFn` (a spread def) and `TData` defaults to it when `map` is absent. */\nexport interface AppQueriesEntry<TRaw, TData = TRaw> {\n  /** The cache key (from `queryKeys`). */\n  readonly key: QueryKey;\n\n  /** Fetches this entry's raw payload; receives the `AbortSignal` so the request cancels on unmount. */\n  readonly queryFn: (ctx: { signal: AbortSignal }) => Promise<TRaw>;\n\n  /** Maps the raw payload to the domain shape — identity when omitted. */\n  readonly map?: (raw: TRaw) => TData;\n}\n\n/** Represents one entry's slice of a `useAppQueries` batch. */\nexport interface AppQueryResult<TData> {\n  /** The mapped domain payload, or `undefined` until this entry resolves. */\n  readonly data: TData | undefined;\n\n  /** True while this entry has no data yet and a fetch is in flight. */\n  readonly loading: boolean;\n\n  /** This entry's failure coerced to `ApiError`, or `null`. */\n  readonly error: ApiError | null;\n}\n\n/** Defines options for `useAppQueries`. */\nexport interface UseAppQueriesOptions<TRaw, TData = TRaw> {\n  /** The queries to run in parallel — the count may vary. A ref or getter re-builds the batch reactively. */\n  readonly queries: MaybeRefOrGetter<readonly AppQueriesEntry<TRaw, TData>[]>;\n\n  /** Gates the whole batch — skips fetching every entry while `false`. */\n  readonly enabled?: MaybeRefOrGetter<boolean>;\n}\n\n/** Represents a parallel batch's aggregated slice — every member reactive. */\nexport interface UseAppQueriesReturn<TData> {\n  /** One slice per entry, in the order they were given. */\n  readonly results: ComputedRef<readonly AppQueryResult<TData>[]>;\n\n  /** Just the payloads, positionally aligned with the entries. */\n  readonly data: ComputedRef<readonly (TData | undefined)[]>;\n\n  /** True while any entry is still loading. */\n  readonly loading: ComputedRef<boolean>;\n\n  /** Every entry's failure, coerced. */\n  readonly errors: ComputedRef<readonly ApiError[]>;\n}\n\n/** Manages a dynamic batch of parallel queries — wraps `useQueries`, maps each raw→domain, and aggregates loading/errors. */\nexport function useAppQueries<TRaw, TData = TRaw>({\n  queries,\n  enabled,\n}: UseAppQueriesOptions<TRaw, TData>): UseAppQueriesReturn<TData> {\n  // `useQueries` types its result off a tuple of per-entry option types; a homogeneous, run-time\n  // sized array cannot be expressed that way, so the result is asserted — the same widening the\n  // React original applied to `UseQueryResult<TData, Error>[]`.\n  const results = useQueries({\n    queries: computed(() =>\n      toValue(queries).map((entry) => ({\n        queryKey: entry.key,\n        queryFn: ({ signal }: { signal: AbortSignal }) => entry.queryFn({ signal }),\n        select: entry.map ?? ((raw: TRaw) => raw as unknown as TData),\n        enabled: toValue(enabled),\n      })),\n    ),\n  }) as unknown as Ref<readonly QueryObserverResult<TData, Error>[]>;\n\n  const mapped = computed<readonly AppQueryResult<TData>[]>(() =>\n    results.value.map((query) => ({\n      data: query.data,\n      loading: query.isPending && query.isFetching,\n      error: query.error ? toApiError(query.error) : null,\n    })),\n  );\n\n  return {\n    results: mapped,\n    data: computed(() => mapped.value.map((result) => result.data)),\n    loading: computed(() => mapped.value.some((result) => result.loading)),\n    errors: computed(() => mapped.value.flatMap((result) => (result.error ? [result.error] : []))),\n  };\n}\n","import { computed, toValue, type ComputedRef, type MaybeRefOrGetter, type Ref } from 'vue';\nimport { keepPreviousData, useQuery, type QueryKey } from '@tanstack/vue-query';\n\nimport type { ApiError } from '../foundation/http';\n\nimport type { AppQueryMeta } from './CreateQueryClient';\nimport { toApiError } from './ToApiError';\n\n/** Defines options for `useAppPaginatedQuery`. */\nexport interface UseAppPaginatedQueryOptions<TItem, TPage> {\n  /** The base cache key (from `queryKeys`) — the active `page` is appended to form the per-page key. */\n  readonly key: MaybeRefOrGetter<QueryKey>;\n\n  /** Fetches one page; receives the controlled `page` and the `AbortSignal`. */\n  readonly queryFn: (ctx: { page: number; signal: AbortSignal }) => Promise<TPage>;\n\n  /** The controlled page index — the caller owns it; changing it loads that page. A ref or getter drives it reactively (React re-rendered instead). */\n  readonly page: MaybeRefOrGetter<number>;\n\n  /** Extracts items from a page — the page itself is the item array when omitted. */\n  readonly mapPage?: (page: TPage) => readonly TItem[];\n\n  /** Gates the query — skips fetching while `false`. */\n  readonly enabled?: MaybeRefOrGetter<boolean>;\n\n  /** Metadata surfaced to the global `onError` seam — `suppressGlobalError: true` keeps this query's failures out of it. */\n  readonly meta?: AppQueryMeta;\n}\n\n/** Represents a page/offset paginated query's slice — every member reactive. */\nexport interface UseAppPaginatedQueryReturn<TItem, TPage> {\n  /** The current page's items. */\n  readonly items: ComputedRef<readonly TItem[]>;\n\n  /** The raw page as fetched (`TPage`) — total count / page count / `hasMore` live here; `undefined` until the first page resolves. While `isPlaceholder`, it is the held previous page. */\n  readonly page: Ref<TPage | undefined>;\n\n  /** True while there is no page yet and a fetch is in flight. */\n  readonly loading: ComputedRef<boolean>;\n\n  /** The failure coerced to `ApiError`, or `null`. */\n  readonly error: ComputedRef<ApiError | null>;\n\n  /** True while the held previous page is being shown during a page change. */\n  readonly isPlaceholder: Ref<boolean>;\n\n  /** Refetches the active page. */\n  readonly refetch: () => unknown;\n}\n\n/** Manages page/offset pagination — wraps `useQuery` with `keepPreviousData` so the list holds steady between pages. */\nexport function useAppPaginatedQuery<TItem, TPage>({\n  key,\n  queryFn,\n  page,\n  mapPage,\n  enabled,\n  meta,\n}: UseAppPaginatedQueryOptions<TItem, TPage>): UseAppPaginatedQueryReturn<TItem, TPage> {\n  const query = useQuery<TPage, Error, TPage, QueryKey>(() => ({\n    queryKey: [...toValue(key), toValue(page)],\n    queryFn: ({ signal }) => queryFn({ page: toValue(page), signal }),\n    placeholderData: keepPreviousData,\n    enabled: toValue(enabled),\n    meta,\n  }));\n\n  const items = computed<readonly TItem[]>(() => {\n    const data = query.data.value;\n    if (data === undefined) return [];\n    return mapPage ? mapPage(data) : (data as unknown as readonly TItem[]);\n  });\n\n  return {\n    items,\n    page: query.data,\n    loading: computed(() => query.isPending.value && query.isFetching.value),\n    error: computed(() => (query.error.value ? toApiError(query.error.value) : null)),\n    isPlaceholder: query.isPlaceholderData,\n    refetch: query.refetch,\n  };\n}\n","import type { IHasItems, TokenPage } from '../foundation/http';\n\n// Ergonomic glue between the `foundation/http` pagination contracts (`Page` / `TokenPage`) and the\n// paging hooks — fully additive, so a product binding `TPage = Page<T>` / `TokenPage<T>` drops the\n// hand-written `getNextPageParam` / `mapPage` boilerplate.\n\n/**\n * A ready `getNextPageParam` for `useAppInfiniteQuery` over `TokenPage` pages — reads `nextPageToken`,\n * returning `undefined` on the last page (an absent token stops paging).\n *\n * `useAppInfiniteQuery<TItem, TokenPage<TItem>>({ getNextPageParam: byPageToken<TItem>(), … })`\n */\nexport function byPageToken<TItem, TToken = string>(): (lastPage: TokenPage<TItem, TToken>) => TToken | undefined {\n  return (lastPage) => lastPage.nextPageToken;\n}\n\n/** A ready `mapPage` for any `IHasItems` page — pass `mapPage: pageItems` instead of `(p) => p.items`. */\nexport function pageItems<T>(page: IHasItems<T>): readonly T[] {\n  return page.items;\n}\n","import { shallowRef, toValue, type MaybeRefOrGetter, type Ref } from 'vue';\nimport { useQueryClient, type QueryKey } from '@tanstack/vue-query';\n\nimport type { ApiError } from '../foundation/http';\n\nimport type { AppQueryMeta } from './CreateQueryClient';\nimport { toApiError } from './ToApiError';\n\n/** Defines options for `useAppLazyQuery` — `TRaw` first so it infers from `queryFn` (a spread def) and `TData` defaults to it when `map` is absent. */\nexport interface UseAppLazyQueryOptions<TRaw, TData = TRaw> {\n  /** The cache key (from `queryKeys`) — read at each `fetch()`, so a ref or getter re-keys the next call. */\n  readonly key: MaybeRefOrGetter<QueryKey>;\n\n  /** Fetches the raw payload; receives the `AbortSignal`. */\n  readonly queryFn: (ctx: { signal: AbortSignal }) => Promise<TRaw>;\n\n  /** Maps the raw payload to the domain shape — identity when omitted. */\n  readonly map?: (raw: TRaw) => TData;\n\n  /** Metadata surfaced to the global `onError` seam — `suppressGlobalError: true` keeps this query's failures out of it. */\n  readonly meta?: AppQueryMeta;\n}\n\n/** Represents an imperative query's slice — state as refs, plus the two commands. */\nexport interface UseAppLazyQueryReturn<TData> {\n  /** The mapped payload from the latest settled `fetch()`, or `undefined` while idle. */\n  readonly data: Ref<TData | undefined>;\n\n  /** True while a `fetch()` is in flight. */\n  readonly loading: Ref<boolean>;\n\n  /** The latest failure coerced to `ApiError`, or `null`. */\n  readonly error: Ref<ApiError | null>;\n\n  /** Runs the request on demand; resolves the mapped data and rejects with the raw error. */\n  readonly fetch: () => Promise<TData>;\n\n  /** Returns the hook to its idle state and orphans any in-flight call. */\n  readonly reset: () => void;\n}\n\n/**\n * Manages an imperative query — does not fetch on mount; `fetch()` runs the request on demand,\n * caching by key via the client (which dedupes concurrent calls and serves a still-fresh cache entry\n * without refetching — the client's `staleTime` window applies). Drives local `data`/`loading`/`error`\n * state with latest-call-wins semantics: a slower earlier `fetch()` (or one orphaned by `reset`) never\n * overwrites newer state, though every call's promise still settles with its own outcome. `fetch()`\n * resolves the mapped data and rejects with the raw error, while `error` holds the coerced `ApiError`.\n * For fetch-on-submit / export-on-click flows. `reset` returns it to the idle state.\n */\nexport function useAppLazyQuery<TRaw, TData = TRaw>({\n  key,\n  queryFn,\n  map,\n  meta,\n}: UseAppLazyQueryOptions<TRaw, TData>): UseAppLazyQueryReturn<TData> {\n  const client = useQueryClient();\n\n  const data = shallowRef<TData | undefined>(undefined);\n  const loading = shallowRef(false);\n  const error = shallowRef<ApiError | null>(null);\n\n  // Sequences fetches so only the LATEST call writes state — a slow earlier fetch (or one orphaned\n  // by `reset`) settling late must not clobber newer data or resurrect a reset hook. The returned\n  // promise still resolves/rejects with its own outcome for every caller. A plain local: never\n  // rendered, so reactivity would be waste.\n  let sequence = 0;\n\n  const fetch = async (): Promise<TData> => {\n    const current = ++sequence;\n    loading.value = true;\n    error.value = null;\n    try {\n      const raw = await client.fetchQuery<TRaw, Error, TRaw, QueryKey>({\n        queryKey: toValue(key),\n        queryFn: ({ signal }) => queryFn({ signal }),\n        meta,\n      });\n      const mapped = map ? map(raw) : (raw as unknown as TData);\n      if (current === sequence) {\n        data.value = mapped;\n        loading.value = false;\n      }\n      return mapped;\n    } catch (caught) {\n      if (current === sequence) {\n        error.value = toApiError(caught);\n        loading.value = false;\n      }\n      throw caught;\n    }\n  };\n\n  const reset = (): void => {\n    sequence += 1; // orphan any in-flight fetch — its late settle no longer writes state\n    data.value = undefined;\n    error.value = null;\n    loading.value = false;\n  };\n\n  return { data, loading, error, fetch, reset };\n}\n","import { useQueryClient, type QueryKey } from '@tanstack/vue-query';\n\n/** Defines a prefetch target for the query cache — a key paired with its fetcher. */\nexport interface QueryCachePrefetch {\n  /** The query key to warm — the same key the live query reads. */\n  readonly key: QueryKey;\n\n  /** Fetches the data to cache; receives the `AbortSignal`. */\n  readonly queryFn: (ctx: { signal: AbortSignal }) => Promise<unknown>;\n}\n\n/** Defines the imperative cache accessor returned by `useQueryCache`. */\nexport interface QueryCacheApi {\n  /** Reads the cached value at `key`, or `undefined` when absent. */\n  readonly get: <TData>(key: QueryKey) => TData | undefined;\n\n  /** Writes `key` — a value, or an updater `(previous) => next` (the TanStack setter form). */\n  readonly set: <TData>(key: QueryKey, data: TData | ((previous: TData | undefined) => TData)) => void;\n\n  /** Marks the queries under `key` stale and refetches the active ones. */\n  readonly invalidate: (key: QueryKey) => Promise<void>;\n\n  /** Removes the queries under `key` from the cache. */\n  readonly remove: (key: QueryKey) => void;\n\n  /** Warms `key` in the background — deduped against a live query. */\n  readonly prefetch: (target: QueryCachePrefetch) => Promise<void>;\n}\n\n/**\n * Provides access to the query cache — imperative get/set/invalidate/remove/prefetch by key,\n * wrapping the active `QueryClient`.\n *\n * Returns a plain object, as React did. There is nothing reactive here: every member is a command,\n * and the client is stable for the component's lifetime, so React's `useMemo` has no counterpart.\n */\nexport function useQueryCache(): QueryCacheApi {\n  const client = useQueryClient();\n\n  return {\n    get: <TData>(key: QueryKey): TData | undefined => client.getQueryData<TData>(key),\n    set: <TData>(key: QueryKey, data: TData | ((previous: TData | undefined) => TData)): void => {\n      client.setQueryData<TData>(key, data);\n    },\n    invalidate: (key: QueryKey): Promise<void> => client.invalidateQueries({ queryKey: key }),\n    remove: (key: QueryKey): void => {\n      client.removeQueries({ queryKey: key });\n    },\n    prefetch: ({ key, queryFn }: QueryCachePrefetch): Promise<void> =>\n      client.prefetchQuery({ queryKey: key, queryFn: ({ signal }) => queryFn({ signal }) }),\n  };\n}\n","import { onScopeDispose } from 'vue';\nimport { useQueryClient, type QueryClient, type QueryKey } from '@tanstack/vue-query';\n\n/**\n * The app client bound by the most recently mounted `usePrefetchQuery`. Powers the standalone\n * `prefetchProps`, mirroring the router's module-level prefetch registry — data prefetch needs a\n * client, so the composable binds it here.\n */\nlet activeClient: QueryClient | undefined;\n\n/** Defines a prefetch target — a query key paired with its fetcher. */\nexport interface PrefetchTarget {\n  /** The query key to warm — the same key the live query reads. */\n  readonly key: QueryKey;\n\n  /** Fetches the data to cache; receives the abort signal the library manages. */\n  readonly queryFn: (context: { signal: AbortSignal }) => Promise<unknown>;\n}\n\n/**\n * Defines the hover/focus listeners to `v-bind` onto a link for data prefetch.\n *\n * `onMouseenter`, not React's `onMouseEnter`: Vue derives the DOM event name with `hyphenate()`, so\n * a camel-humped `onMouseEnter` key would bind a `mouse-enter` event that never fires.\n */\nexport interface PrefetchProps {\n  /** Warms the target query when the pointer enters the link. */\n  readonly onMouseenter: () => void;\n\n  /** Warms the target query when the link gains focus. */\n  readonly onFocus: () => void;\n}\n\n/** Warms a query's data against a client — a background fetch deduped against the live query. */\nfunction warm(client: QueryClient, { key, queryFn }: PrefetchTarget): void {\n  void client.prefetchQuery({ queryKey: key, queryFn });\n}\n\n/** Manages intent-based data prefetch — returns a `prefetch(target)` that warms a query on hover/focus. */\nexport function usePrefetchQuery(): (target: PrefetchTarget) => void {\n  const client = useQueryClient();\n\n  // Bind the client for the standalone `prefetchProps`, mirroring the router's registry. React did\n  // this in an effect; the scope teardown is the Vue counterpart of that effect's cleanup.\n  activeClient = client;\n  onScopeDispose(() => {\n    if (activeClient === client) activeClient = undefined;\n  });\n\n  return (target: PrefetchTarget) => warm(client, target);\n}\n\n/** Builds hover/focus listeners that warm a query's data on intent — `v-bind` onto a link beside the router's `prefetchProps`. Requires a mounted `usePrefetchQuery`. */\nexport function prefetchProps(target: PrefetchTarget): PrefetchProps {\n  const run = (): void => {\n    if (activeClient) warm(activeClient, target);\n  };\n  return { onMouseenter: run, onFocus: run };\n}\n","import { toValue, type MaybeRefOrGetter, type Ref } from 'vue';\nimport { useQuery, type QueryKey } from '@tanstack/vue-query';\n\nimport type { AppQueryMeta } from './CreateQueryClient';\n\n/** Defines a suspenseful query — a key, a fetcher, and an optional raw→view mapper. `TRaw` first so it infers from `queryFn` (a spread def); `TData` defaults to it when `map` is absent. */\nexport interface AppSuspenseQueryOptions<TRaw, TData = TRaw> {\n  /** The query key that identifies and caches this query. */\n  readonly key: MaybeRefOrGetter<QueryKey>;\n\n  /** Fetches the raw data; receives the abort signal the library manages. */\n  readonly queryFn: (context: { signal: AbortSignal }) => Promise<TRaw>;\n\n  /** Maps the raw fetched shape to the view shape; identity when omitted. */\n  readonly map?: (raw: TRaw) => TData;\n\n  /** Metadata surfaced to the global `onError` seam — `suppressGlobalError: true` keeps this query's failures out of it (boundary-handled errors would otherwise double-surface). */\n  readonly meta?: AppQueryMeta;\n}\n\n/** Represents a resolved suspenseful query — `data` is already filled when the composable resolves. */\nexport interface AppSuspenseQueryReturn<TData> {\n  /** The resolved payload. Defined on resolve, and kept live afterwards. */\n  readonly data: Ref<TData>;\n\n  /** Refetches the query. */\n  readonly refetch: () => unknown;\n}\n\n/**\n * Manages a suspenseful query — the composable AWAITS the first resolution, so a `<script setup>`\n * that awaits it suspends until data is there.\n *\n * ```vue\n * <script setup lang=\"ts\">\n * const { data } = await useAppSuspenseQuery({ key: ['user'], queryFn });\n * </script>\n * ```\n *\n * `@tanstack/vue-query` ships no `useSuspenseQuery` — Vue suspends on an async `setup()` rather than\n * on a thrown promise, so the library exposes `suspense()` on the query result and this awaits it.\n * That makes this composable ASYNC where React's was synchronous, the one shape change the two\n * suspense models force.\n *\n * The caller still owns both boundaries: a `<Suspense>` for loading, and an error boundary for\n * failure — a rejected query rejects this promise and bubbles past the hook.\n */\nexport async function useAppSuspenseQuery<TRaw, TData = TRaw>({\n  key,\n  queryFn,\n  map,\n  meta,\n}: AppSuspenseQueryOptions<TRaw, TData>): Promise<AppSuspenseQueryReturn<TData>> {\n  const query = useQuery<TRaw, Error, TData, QueryKey>(() => ({\n    queryKey: toValue(key),\n    queryFn: ({ signal }) => queryFn({ signal }),\n    select: map,\n    meta,\n  }));\n\n  const result = await query.suspense();\n  if (result.error) throw result.error; // `suspense()` settles on failure too — rethrow for the boundary\n\n  // `data` is `Ref<TData | undefined>` in general; the await above is what makes it defined here.\n  return { data: query.data as Ref<TData>, refetch: query.refetch };\n}\n","import { defineComponent, onScopeDispose, watch } from 'vue';\nimport { useIsFetching, useIsMutating } from '@tanstack/vue-query';\n\n// Deep import (not the `../router` barrel): the barrel statically imports vue-router, and a barrel\n// import here would merge the whole router graph into the shared chunk `/query` loads — breaking\n// `/query`'s isolation from the OPTIONAL vue-router peer. `UseNavigationProgress` is plain Vue.\nimport { useNavigationProgress } from '../router/UseNavigationProgress';\n\n/**\n * Lights the router's manual heartbeat while the query layer has any fetch or mutation in flight.\n *\n * Call inside BOTH a query client scope (`queryPlugin` / `<QueryProvider>`) and a `<ProgressProvider>`\n * — `useNavigationProgress` THROWS outside one. Wires effects only; it drives\n * `<NavigationProgress variant=\"heartbeat\" mode=\"manual\" />`.\n */\nexport function useQueryProgressBridge(): void {\n  const fetching = useIsFetching();\n  const mutating = useIsMutating();\n  const { begin } = useNavigationProgress();\n\n  let end: (() => void) | null = null;\n\n  // Open a manual busy span on 0→>0, close it on >0→0. `flush: 'sync'` is deliberately NOT used —\n  // the default pre-flush is enough, and the callback touches no browser global, so it is SSR-safe\n  // even though `immediate` runs it on the server.\n  watch(\n    () => fetching.value + mutating.value,\n    (activity) => {\n      if (activity > 0 && end === null) end = begin();\n      else if (activity === 0 && end !== null) {\n        end();\n        end = null;\n      }\n    },\n    { immediate: true },\n  );\n\n  // Close any still-open span when the bridge's scope is disposed mid-request.\n  onScopeDispose(() => {\n    end?.();\n    end = null;\n  });\n}\n\n/**\n * Renders nothing; wires `useQueryProgressBridge`.\n *\n * The component form React shipped, kept so an app can drop `<QueryProgressBridge />` into its\n * shell unchanged. Authored as a `defineComponent` rather than an SFC — it has no template.\n */\nexport const QueryProgressBridge = defineComponent({\n  name: 'QueryProgressBridge',\n  setup() {\n    useQueryProgressBridge();\n    return () => null;\n  },\n});\n","<script lang=\"ts\">\n/** Defines the props for {@link QueryDevtools}. */\nexport interface QueryDevtoolsProps {\n  /** Whether the panel starts open. Default `false`. */\n  initialIsOpen?: boolean;\n}\n\n/*\n * The devtools specifier, assembled at runtime.\n *\n * `@tanstack/vue-query-devtools` is NOT a dependency of this package — devtools are the app's\n * choice, and a library must not force one. A literal specifier would make the bundler resolve\n * (and therefore require) it at build time even inside a dead `import.meta.env.DEV` branch, so the\n * string is built here and the import stays opaque. The app installs the package to get the panel;\n * without it the component renders nothing and says nothing.\n */\nconst DevtoolsPackage = ['@tanstack', 'vue-query-devtools'].join('/');\n</script>\n\n<script setup lang=\"ts\">\nimport { onMounted, shallowRef, type Component } from 'vue';\n\n/** Renders the TanStack Query devtools in dev only, when the optional devtools package is installed. */\ndefineOptions({ name: 'QueryDevtools' });\n\nconst props = withDefaults(defineProps<QueryDevtoolsProps>(), { initialIsOpen: false });\n\nconst devtools = shallowRef<Component | null>(null);\n\n// `onMounted` never runs on the server, and the import is dev-only — production tree-shakes the\n// branch away because `import.meta.env.DEV` is statically false there.\nonMounted(async () => {\n  if (!import.meta.env.DEV) return;\n  try {\n    const module = (await import(/* @vite-ignore */ DevtoolsPackage)) as { VueQueryDevtools?: Component };\n    devtools.value = module.VueQueryDevtools ?? null;\n  } catch {\n    // Devtools not installed — the normal case for an app that never opted in.\n  }\n});\n</script>\n\n<template>\n  <component :is=\"devtools\" v-if=\"devtools\" :initial-is-open=\"props.initialIsOpen\" />\n</template>\n","import { dehydrate, hydrate, type DehydratedState, type QueryClient } from '@tanstack/vue-query';\n\nconst DefaultStorageKey = 'app:query-cache';\nconst DefaultMaxAgeMs = 24 * 60 * 60_000; // 24h\nconst WriteThrottleMs = 1_000;\n\n/** The envelope written to storage — the dehydrated cache plus what restore has to validate before trusting it. */\ninterface PersistedSnapshot {\n  readonly buster: string;\n  readonly timestamp: number;\n  readonly state: DehydratedState;\n}\n\n/** Defines options for `setupQueryPersistence`. */\nexport interface SetupQueryPersistenceOptions {\n  /** The `localStorage` key the dehydrated cache is written under. */\n  readonly storageKey?: string;\n  /** The max age of a restored cache in ms; an older cache is discarded on restore. */\n  readonly maxAgeMs?: number;\n  /** A cache-busting string; a mismatch discards the persisted cache. */\n  readonly buster?: string;\n}\n\n/** Represents the handles returned by `setupQueryPersistence`. */\nexport interface QueryPersistenceHandle {\n  /** Stops persisting further cache changes. */\n  readonly unsubscribe: () => void;\n  /** Resolves once the persisted cache has been restored into the client. */\n  readonly restored: Promise<void>;\n}\n\n/**\n * Wires `localStorage` persistence for the query cache (opt-in — call from `main.ts`); returns null\n * when there is no `window` (SSR-safe).\n *\n * Built on `dehydrate` / `hydrate` straight out of `@tanstack/vue-query` rather than on the\n * `persist-client` + `sync-storage-persister` package pair the React version used: those two are\n * separate installs, and the whole of what they add over this is an async persister interface this\n * synchronous store does not need. The restore is therefore SYNCHRONOUS — the cache is already\n * hydrated when the call returns, and `restored` is an already-settled promise kept for API parity.\n *\n * Caveats to weigh before opting in:\n * - **Sensitive data** — every successful query dehydrates into `localStorage` in plain text,\n *   including authenticated user data; any script on the origin can read it. Do not enable on apps\n *   whose cache holds secrets/PII, or scope what queries cache to begin with.\n * - **Version busting** — pass `buster` (e.g. the app version) whenever a release changes cached\n *   shapes; a restored stale shape otherwise flows into typed hooks unchecked.\n * - **Quota** — a full `localStorage` makes the write silently fail (no retry strategy is wired);\n *   the app keeps working, persistence just lags.\n * - **Temporal revive** — payloads parsed via `reviveTemporal` serialize to ISO strings and are\n *   restored WITHOUT re-reviving: restored entries hold plain strings where live fetches hold\n *   `Temporal.*` objects. Don't combine persistence with `reviveTemporal` yet.\n */\nexport function setupQueryPersistence(\n  client: QueryClient,\n  options: SetupQueryPersistenceOptions = {},\n): QueryPersistenceHandle | null {\n  if (typeof window === 'undefined') return null;\n\n  const { storageKey = DefaultStorageKey, maxAgeMs = DefaultMaxAgeMs, buster = '' } = options;\n\n  restore(client, storageKey, maxAgeMs, buster);\n\n  // Throttled: a burst of cache events (one query settling touches the cache several times) must not\n  // serialize the whole cache once per event.\n  let timer: ReturnType<typeof setTimeout> | null = null;\n  const schedule = (): void => {\n    if (timer !== null) return;\n    timer = setTimeout(() => {\n      timer = null;\n      write(client, storageKey, buster);\n    }, WriteThrottleMs);\n  };\n\n  const unsubscribeQueries = client.getQueryCache().subscribe(schedule);\n  const unsubscribeMutations = client.getMutationCache().subscribe(schedule);\n\n  return {\n    unsubscribe: () => {\n      unsubscribeQueries();\n      unsubscribeMutations();\n      if (timer !== null) {\n        clearTimeout(timer);\n        timer = null;\n      }\n    },\n    restored: Promise.resolve(),\n  };\n}\n\n/** Hydrates the client from storage when the snapshot is present, current, and matches the buster. */\nfunction restore(client: QueryClient, storageKey: string, maxAgeMs: number, buster: string): void {\n  try {\n    const raw = window.localStorage.getItem(storageKey);\n    if (!raw) return;\n\n    const snapshot = JSON.parse(raw) as PersistedSnapshot;\n    const isStale = Date.now() - snapshot.timestamp > maxAgeMs;\n    if (snapshot.buster !== buster || isStale) {\n      window.localStorage.removeItem(storageKey);\n      return;\n    }\n\n    hydrate(client, snapshot.state);\n  } catch {\n    // Unreadable / unparseable / storage unavailable — a missing cache is always a valid state.\n  }\n}\n\n/** Serializes the dehydrated cache into storage, tolerating storage being unavailable (private mode / quota). */\nfunction write(client: QueryClient, storageKey: string, buster: string): void {\n  try {\n    const snapshot: PersistedSnapshot = { buster, timestamp: Date.now(), state: dehydrate(client) };\n    window.localStorage.setItem(storageKey, JSON.stringify(snapshot));\n  } catch {\n    // Persistence is best-effort — swallow.\n  }\n}\n"],"names":["_renderSlot","_openBlock","_createBlock","_resolveDynamicComponent"],"mappings":"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"}

package/dist/query/testing.d.ts

@@ -0,0 +1 @@
+export { createTestQueryClient, mountWithQuery, renderWithQuery, createQueryWrapper, runWithQuery, type MountWithQueryOptions, type MountWithQueryResult, type RunWithQueryResult, } from './QueryTestUtils';

package/dist/query/testing.js

@@ -0,0 +1,48 @@
+import { defineComponent, createApp } from "vue";
+import { QueryClient } from "@tanstack/vue-query";
+import { mount } from "@vue/test-utils";
+import { q as queryPlugin } from "../chunks/QueryPlugin-CfotNm6j.js";
+const GcTimeMs = Infinity;
+function createTestQueryClient() {
+  return new QueryClient({
+    defaultOptions: {
+      queries: { retry: false, gcTime: GcTimeMs, refetchOnWindowFocus: false },
+      mutations: { retry: false }
+    }
+  });
+}
+function mountWithQuery(component, options = {}) {
+  const { client = createTestQueryClient(), ...rest } = options;
+  const globalOptions = rest.global ?? {};
+  const wrapper = mount(component, {
+    ...rest,
+    global: { ...globalOptions, plugins: [...globalOptions.plugins ?? [], queryPlugin(client)] }
+  });
+  return Object.assign(wrapper, { client });
+}
+const renderWithQuery = mountWithQuery;
+function createQueryWrapper(client = createTestQueryClient()) {
+  return { global: { plugins: [queryPlugin(client)] } };
+}
+function runWithQuery(composable, client = createTestQueryClient()) {
+  let result;
+  const host = defineComponent({
+    name: "QueryComposableHost",
+    setup() {
+      result = composable();
+      return () => null;
+    }
+  });
+  const app = createApp(host);
+  app.use(queryPlugin(client));
+  app.mount(document.createElement("div"));
+  return { result, client, app, unmount: () => app.unmount() };
+}
+export {
+  createQueryWrapper,
+  createTestQueryClient,
+  mountWithQuery,
+  renderWithQuery,
+  runWithQuery
+};
+//# sourceMappingURL=testing.js.map