@pyreon/query 0.0.1

package/lib/types/index2.d.ts

@@ -0,0 +1,298 @@
+import { CancelledError, DefaultError, DehydratedState, FetchQueryOptions, InfiniteData, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, InvalidateOptions, InvalidateQueryFilters, MutateFunction, MutationCache, MutationFilters, MutationFilters as MutationFilters$1, MutationObserverOptions, MutationObserverResult, QueryCache, QueryClient, QueryClient as QueryClient$1, QueryClientConfig, QueryFilters, QueryFilters as QueryFilters$1, QueryKey, QueryKey as QueryKey$1, QueryObserverOptions, QueryObserverResult, RefetchOptions, RefetchQueryFilters, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, hashKey, hydrate, isCancelledError, keepPreviousData } from "@tanstack/query-core";
+import * as _pyreon_core0 from "@pyreon/core";
+import { Props, VNode, VNodeChild } from "@pyreon/core";
+import { Signal } from "@pyreon/reactivity";
+
+//#region src/query-client.d.ts
+interface QueryClientProviderProps extends Props {
+  client: QueryClient$1;
+  children?: VNodeChild;
+}
+declare const QueryClientContext: _pyreon_core0.Context<QueryClient$1 | null>;
+/**
+ * Provides a QueryClient to all descendant components via context.
+ * Wrap your app root with this to enable useQuery / useMutation throughout the tree.
+ *
+ * @example
+ * const client = new QueryClient()
+ * mount(h(QueryClientProvider, { client }, h(App, null)), el)
+ */
+declare function QueryClientProvider(props: QueryClientProviderProps): VNode;
+/**
+ * Returns the nearest QueryClient provided by <QueryClientProvider>.
+ * Throws if called outside of one.
+ */
+declare function useQueryClient(): QueryClient$1;
+//#endregion
+//#region src/use-query.d.ts
+interface UseQueryResult<TData, TError = DefaultError> {
+  /** Raw signal — the full observer result. Fine-grained accessors below are preferred. */
+  result: Signal<QueryObserverResult<TData, TError>>;
+  data: Signal<TData | undefined>;
+  error: Signal<TError | null>;
+  status: Signal<'pending' | 'error' | 'success'>;
+  isPending: Signal<boolean>;
+  isLoading: Signal<boolean>;
+  isFetching: Signal<boolean>;
+  isError: Signal<boolean>;
+  isSuccess: Signal<boolean>;
+  /** Manually trigger a refetch. */
+  refetch: () => Promise<QueryObserverResult<TData, TError>>;
+}
+/**
+ * Subscribe to a query. Returns fine-grained reactive signals for data,
+ * error and status — each signal only notifies effects that depend on it.
+ *
+ * `options` is a function so it can read Pyreon signals — when a signal changes
+ * (e.g. a reactive query key), the observer is updated and refetches automatically.
+ *
+ * @example
+ * const userId = signal(1)
+ * const query = useQuery(() => ({
+ *   queryKey: ['user', userId()],
+ *   queryFn: () => fetch(`/api/users/${userId()}`).then(r => r.json()),
+ * }))
+ * // In template: () => query.data()?.name
+ */
+declare function useQuery<TData = unknown, TError = DefaultError, TKey extends QueryKey$1 = QueryKey$1>(options: () => QueryObserverOptions<TData, TError, TData, TData, TKey>): UseQueryResult<TData, TError>;
+//#endregion
+//#region src/use-mutation.d.ts
+interface UseMutationResult<TData, TError = DefaultError, TVariables = void, TContext = unknown> {
+  /** Raw signal — full observer result. Fine-grained accessors below are preferred. */
+  result: Signal<MutationObserverResult<TData, TError, TVariables, TContext>>;
+  data: Signal<TData | undefined>;
+  error: Signal<TError | null>;
+  status: Signal<'idle' | 'pending' | 'success' | 'error'>;
+  isPending: Signal<boolean>;
+  isSuccess: Signal<boolean>;
+  isError: Signal<boolean>;
+  isIdle: Signal<boolean>;
+  /** Fire the mutation (fire-and-forget). Errors are captured in the error signal. */
+  mutate: (variables: TVariables, options?: Parameters<MutateFunction<TData, TError, TVariables, TContext>>[1]) => void;
+  /** Like mutate but returns a promise — use for try/catch error handling. */
+  mutateAsync: MutateFunction<TData, TError, TVariables, TContext>;
+  /** Reset the mutation state back to idle. */
+  reset: () => void;
+}
+/**
+ * Run a mutation (create / update / delete). Returns reactive signals for
+ * pending / success / error state plus `mutate` and `mutateAsync` functions.
+ *
+ * @example
+ * const mutation = useMutation({
+ *   mutationFn: (data: CreatePostInput) =>
+ *     fetch('/api/posts', { method: 'POST', body: JSON.stringify(data) }).then(r => r.json()),
+ *   onSuccess: () => client.invalidateQueries({ queryKey: ['posts'] }),
+ * })
+ * // h('button', { onClick: () => mutation.mutate({ title: 'New' }) }, 'Create')
+ */
+declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: MutationObserverOptions<TData, TError, TVariables, TContext>): UseMutationResult<TData, TError, TVariables, TContext>;
+//#endregion
+//#region src/use-infinite-query.d.ts
+interface UseInfiniteQueryResult<TQueryFnData, TError = DefaultError> {
+  /** Raw signal — full observer result. */
+  result: Signal<InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
+  data: Signal<InfiniteData<TQueryFnData> | undefined>;
+  error: Signal<TError | null>;
+  status: Signal<'pending' | 'error' | 'success'>;
+  isPending: Signal<boolean>;
+  isLoading: Signal<boolean>;
+  isFetching: Signal<boolean>;
+  isFetchingNextPage: Signal<boolean>;
+  isFetchingPreviousPage: Signal<boolean>;
+  isError: Signal<boolean>;
+  isSuccess: Signal<boolean>;
+  hasNextPage: Signal<boolean>;
+  hasPreviousPage: Signal<boolean>;
+  fetchNextPage: () => Promise<InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
+  fetchPreviousPage: () => Promise<InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
+  refetch: () => Promise<QueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
+}
+/**
+ * Subscribe to a paginated / infinite-scroll query.
+ * Returns fine-grained reactive signals plus `fetchNextPage`, `fetchPreviousPage`,
+ * `hasNextPage` and `hasPreviousPage`.
+ *
+ * @example
+ * const query = useInfiniteQuery(() => ({
+ *   queryKey: ['posts'],
+ *   queryFn: ({ pageParam }) => fetchPosts(pageParam as number),
+ *   initialPageParam: 0,
+ *   getNextPageParam: (lastPage) => lastPage.nextCursor,
+ * }))
+ * // query.data()?.pages  — array of pages
+ * // h('button', { onClick: () => query.fetchNextPage() }, 'Load more')
+ */
+declare function useInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TQueryKey extends QueryKey$1 = QueryKey$1, TPageParam = unknown>(options: () => InfiniteQueryObserverOptions<TQueryFnData, TError, InfiniteData<TQueryFnData>, TQueryKey, TPageParam>): UseInfiniteQueryResult<TQueryFnData, TError>;
+//#endregion
+//#region src/use-is-fetching.d.ts
+/**
+ * Returns a signal that tracks how many queries are currently in-flight.
+ * Useful for global loading indicators.
+ *
+ * @example
+ * const fetching = useIsFetching()
+ * // h('span', null, () => fetching() > 0 ? 'Loading…' : '')
+ */
+declare function useIsFetching(filters?: QueryFilters$1): Signal<number>;
+/**
+ * Returns a signal that tracks how many mutations are currently in-flight.
+ *
+ * @example
+ * const mutating = useIsMutating()
+ * // h('span', null, () => mutating() > 0 ? 'Saving…' : '')
+ */
+declare function useIsMutating(filters?: MutationFilters$1): Signal<number>;
+//#endregion
+//#region src/use-queries.d.ts
+type UseQueriesOptions<TQueryKey extends QueryKey$1 = QueryKey$1> = QueryObserverOptions<unknown, DefaultError, unknown, unknown, TQueryKey>;
+/**
+ * Subscribe to multiple queries in parallel. Returns a single signal containing
+ * the array of results — index-aligned with the `queries` array.
+ *
+ * `queries` is a reactive function so signal-based keys trigger re-evaluation
+ * automatically.
+ *
+ * @example
+ * const userIds = signal([1, 2, 3])
+ * const results = useQueries(() =>
+ *   userIds().map(id => ({
+ *     queryKey: ['user', id],
+ *     queryFn: () => fetchUser(id),
+ *   }))
+ * )
+ * // results() — QueryObserverResult[]
+ * // results()[0].data — first user
+ */
+declare function useQueries(queries: () => UseQueriesOptions[]): Signal<QueryObserverResult[]>;
+//#endregion
+//#region src/use-suspense-query.d.ts
+/**
+ * Like `UseQueryResult` but `data` is `Signal<TData>` (never undefined).
+ * Only use inside a `QuerySuspense` boundary which guarantees the query has
+ * succeeded before children are rendered.
+ */
+interface UseSuspenseQueryResult<TData, TError = DefaultError> {
+  result: Signal<QueryObserverResult<TData, TError>>;
+  /** Always TData — never undefined inside a QuerySuspense boundary. */
+  data: Signal<TData>;
+  error: Signal<TError | null>;
+  status: Signal<'pending' | 'error' | 'success'>;
+  isPending: Signal<boolean>;
+  isFetching: Signal<boolean>;
+  isError: Signal<boolean>;
+  isSuccess: Signal<boolean>;
+  refetch: () => Promise<QueryObserverResult<TData, TError>>;
+}
+interface UseSuspenseInfiniteQueryResult<TQueryFnData, TError = DefaultError> {
+  result: Signal<InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
+  /** Always InfiniteData<TQueryFnData> — never undefined inside a QuerySuspense boundary. */
+  data: Signal<InfiniteData<TQueryFnData>>;
+  error: Signal<TError | null>;
+  status: Signal<'pending' | 'error' | 'success'>;
+  isFetching: Signal<boolean>;
+  isFetchingNextPage: Signal<boolean>;
+  isFetchingPreviousPage: Signal<boolean>;
+  isError: Signal<boolean>;
+  isSuccess: Signal<boolean>;
+  hasNextPage: Signal<boolean>;
+  hasPreviousPage: Signal<boolean>;
+  fetchNextPage: () => Promise<InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
+  fetchPreviousPage: () => Promise<InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
+  refetch: () => Promise<QueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
+}
+type AnyQueryLike = {
+  isPending: Signal<boolean>;
+  isError: Signal<boolean>;
+  error: Signal<unknown>;
+};
+interface QuerySuspenseProps {
+  /**
+   * A single query result (or array of them) to gate on.
+   * Children only render when ALL queries have succeeded.
+   */
+  query: AnyQueryLike | AnyQueryLike[];
+  /** Rendered while any query is pending. */
+  fallback?: VNodeChild;
+  /** Rendered when any query has errored. Defaults to re-throwing to nearest ErrorBoundary. */
+  error?: (err: unknown) => VNodeChild;
+  children: VNodeChild;
+}
+/**
+ * Pyreon-native Suspense boundary for queries. Shows `fallback` while any query
+ * is pending. On error, renders the `error` fallback or re-throws to the
+ * nearest Pyreon `ErrorBoundary`.
+ *
+ * Pair with `useSuspenseQuery` / `useSuspenseInfiniteQuery` to get non-undefined
+ * `data` types inside children.
+ *
+ * @example
+ * const userQuery = useSuspenseQuery(() => ({ queryKey: ['user'], queryFn: fetchUser }))
+ *
+ * h(QuerySuspense, {
+ *   query: userQuery,
+ *   fallback: h(Spinner, null),
+ *   error: (err) => h('p', null, `Failed: ${err}`),
+ * }, () => h(UserProfile, { user: userQuery.data() }))
+ */
+declare function QuerySuspense(props: QuerySuspenseProps): VNodeChild;
+/**
+ * Like `useQuery` but `data` is typed as `Signal<TData>` (never undefined).
+ * Designed for use inside a `QuerySuspense` boundary, which guarantees
+ * children only render after the query succeeds.
+ *
+ * @example
+ * const user = useSuspenseQuery(() => ({ queryKey: ['user', id()], queryFn: fetchUser }))
+ *
+ * h(QuerySuspense, { query: user, fallback: h(Spinner, null) },
+ *   () => h(UserCard, { name: user.data().name }),
+ * )
+ */
+declare function useSuspenseQuery<TData = unknown, TError = DefaultError, TKey extends QueryKey$1 = QueryKey$1>(options: () => QueryObserverOptions<TData, TError, TData, TData, TKey>): UseSuspenseQueryResult<TData, TError>;
+/**
+ * Like `useInfiniteQuery` but `data` is typed as `Signal<InfiniteData<TData>>`
+ * (never undefined). Use inside a `QuerySuspense` boundary.
+ */
+declare function useSuspenseInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TQueryKey extends QueryKey$1 = QueryKey$1, TPageParam = unknown>(options: () => InfiniteQueryObserverOptions<TQueryFnData, TError, InfiniteData<TQueryFnData>, TQueryKey, TPageParam>): UseSuspenseInfiniteQueryResult<TQueryFnData, TError>;
+//#endregion
+//#region src/use-query-error-reset-boundary.d.ts
+interface ErrorResetBoundaryValue {
+  reset: () => void;
+}
+interface QueryErrorResetBoundaryProps extends Props {
+  children?: VNodeChild;
+}
+/**
+ * Wraps a subtree so that `useQueryErrorResetBoundary()` descendants can reset
+ * all errored queries within this boundary.
+ *
+ * Pair with Pyreon's `ErrorBoundary` to retry failed queries when the user
+ * dismisses the error fallback:
+ *
+ * @example
+ * h(QueryErrorResetBoundary, null,
+ *   h(ErrorBoundary, {
+ *     fallback: (err, boundaryReset) => {
+ *       const { reset } = useQueryErrorResetBoundary()
+ *       return h('button', {
+ *         onClick: () => { reset(); boundaryReset() },
+ *       }, 'Retry')
+ *     },
+ *   }, h(MyComponent, null)),
+ * )
+ */
+declare function QueryErrorResetBoundary(props: QueryErrorResetBoundaryProps): VNode;
+/**
+ * Returns the `reset` function provided by the nearest `QueryErrorResetBoundary`.
+ * If called outside a boundary, falls back to resetting all errored queries
+ * on the current `QueryClient`.
+ *
+ * @example
+ * // Inside an ErrorBoundary fallback:
+ * const { reset } = useQueryErrorResetBoundary()
+ * h('button', { onClick: () => { reset(); boundaryReset() } }, 'Retry')
+ */
+declare function useQueryErrorResetBoundary(): ErrorResetBoundaryValue;
+//#endregion
+export { CancelledError, type DehydratedState, type FetchQueryOptions, type InvalidateOptions, type InvalidateQueryFilters, MutationCache, type MutationFilters, QueryCache, QueryClient, type QueryClientConfig, QueryClientContext, QueryClientProvider, type QueryClientProviderProps, QueryErrorResetBoundary, type QueryErrorResetBoundaryProps, type QueryFilters, type QueryKey, QuerySuspense, type QuerySuspenseProps, type RefetchOptions, type RefetchQueryFilters, type UseInfiniteQueryResult, type UseMutationResult, type UseQueriesOptions, type UseQueryResult, type UseSuspenseInfiniteQueryResult, type UseSuspenseQueryResult, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, hashKey, hydrate, isCancelledError, keepPreviousData, useInfiniteQuery, useIsFetching, useIsMutating, useMutation, useQueries, useQuery, useQueryClient, useQueryErrorResetBoundary, useSuspenseInfiniteQuery, useSuspenseQuery };
+//# sourceMappingURL=index2.d.ts.map

package/lib/types/index2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index2.d.ts","names":[],"sources":["../../src/query-client.ts","../../src/use-query.ts","../../src/use-mutation.ts","../../src/use-infinite-query.ts","../../src/use-is-fetching.ts","../../src/use-queries.ts","../../src/use-suspense-query.ts","../../src/use-query-error-reset-boundary.ts"],"mappings":"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"}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@pyreon/query",
+  "version": "0.0.1",
+  "description": "Pyreon adapter for TanStack Query",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pyreon/fundamentals.git",
+    "directory": "packages/query"
+  },
+  "homepage": "https://github.com/pyreon/fundamentals/tree/main/packages/query#readme",
+  "bugs": {
+    "url": "https://github.com/pyreon/fundamentals/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "lib",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./lib/index.js",
+  "module": "./lib/index.js",
+  "types": "./lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./lib/index.js",
+      "types": "./lib/types/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "vl_rolldown_build",
+    "dev": "vl_rolldown_build-watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@tanstack/query-core": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@pyreon/core": "^0.2.1",
+    "@pyreon/reactivity": "^0.2.1"
+  },
+  "devDependencies": {
+    "@happy-dom/global-registrator": "^20.8.3",
+    "@pyreon/core": "^0.2.1",
+    "@pyreon/reactivity": "^0.2.1",
+    "@pyreon/runtime-dom": "^0.2.1"
+  }
+}

package/src/index.ts

@@ -0,0 +1,69 @@
+// ─── TanStack Query core re-exports ──────────────────────────────────────────
+// Users can import QueryClient, dehydrate, etc. from @pyreon/query directly.
+
+export {
+  QueryClient,
+  QueryCache,
+  MutationCache,
+  dehydrate,
+  hydrate,
+  defaultShouldDehydrateQuery,
+  defaultShouldDehydrateMutation,
+  keepPreviousData,
+  hashKey,
+  isCancelledError,
+  CancelledError,
+} from '@tanstack/query-core'
+
+export type {
+  QueryKey,
+  QueryFilters,
+  MutationFilters,
+  DehydratedState,
+  FetchQueryOptions,
+  InvalidateQueryFilters,
+  InvalidateOptions,
+  RefetchQueryFilters,
+  RefetchOptions,
+  QueryClientConfig,
+} from '@tanstack/query-core'
+
+// ─── Pyreon adapter ─────────────────────────────────────────────────────────────
+
+export {
+  QueryClientContext,
+  QueryClientProvider,
+  useQueryClient,
+} from './query-client'
+export type { QueryClientProviderProps } from './query-client'
+
+export { useQuery } from './use-query'
+export type { UseQueryResult } from './use-query'
+
+export { useMutation } from './use-mutation'
+export type { UseMutationResult } from './use-mutation'
+
+export { useInfiniteQuery } from './use-infinite-query'
+export type { UseInfiniteQueryResult } from './use-infinite-query'
+
+export { useIsFetching, useIsMutating } from './use-is-fetching'
+
+export { useQueries } from './use-queries'
+export type { UseQueriesOptions } from './use-queries'
+
+export {
+  useSuspenseQuery,
+  useSuspenseInfiniteQuery,
+  QuerySuspense,
+} from './use-suspense-query'
+export type {
+  UseSuspenseQueryResult,
+  UseSuspenseInfiniteQueryResult,
+  QuerySuspenseProps,
+} from './use-suspense-query'
+
+export {
+  QueryErrorResetBoundary,
+  useQueryErrorResetBoundary,
+} from './use-query-error-reset-boundary'
+export type { QueryErrorResetBoundaryProps } from './use-query-error-reset-boundary'

package/src/query-client.ts

@@ -0,0 +1,59 @@
+import {
+  createContext,
+  pushContext,
+  popContext,
+  onMount,
+  onUnmount,
+  useContext,
+} from '@pyreon/core'
+import type { VNodeChild, VNode } from '@pyreon/core'
+import type { QueryClient } from '@tanstack/query-core'
+import type { Props } from '@pyreon/core'
+
+export interface QueryClientProviderProps extends Props {
+  client: QueryClient
+  children?: VNodeChild
+}
+
+export const QueryClientContext = createContext<QueryClient | null>(null)
+
+/**
+ * Provides a QueryClient to all descendant components via context.
+ * Wrap your app root with this to enable useQuery / useMutation throughout the tree.
+ *
+ * @example
+ * const client = new QueryClient()
+ * mount(h(QueryClientProvider, { client }, h(App, null)), el)
+ */
+export function QueryClientProvider(props: QueryClientProviderProps): VNode {
+  // Push synchronously so all descendant component functions see the context.
+  // Pop on unmount (matches the HeadProvider pattern in @pyreon/head).
+  const frame = new Map([[QueryClientContext.id, props.client]])
+  pushContext(frame)
+
+  // client.mount() activates window focus refetching and online/offline handling.
+  // client.unmount() unsubscribes focusManager + onlineManager when the provider leaves the tree.
+  onMount(() => {
+    props.client.mount()
+    return () => props.client.unmount()
+  })
+
+  onUnmount(() => popContext())
+
+  const ch = props.children
+  return (typeof ch === 'function' ? (ch as () => VNodeChild)() : ch) as VNode
+}
+
+/**
+ * Returns the nearest QueryClient provided by <QueryClientProvider>.
+ * Throws if called outside of one.
+ */
+export function useQueryClient(): QueryClient {
+  const client = useContext(QueryClientContext)
+  if (!client) {
+    throw new Error(
+      '[pyreon/query] No QueryClient found. Wrap your app with <QueryClientProvider client={client}>.',
+    )
+  }
+  return client
+}