@analogjs/router 3.0.0-alpha.6 → 3.0.0-alpha.61

package/types/src/lib/routes.d.ts

@@ -1,14 +1,5 @@
 import type { Route } from '@angular/router';
-import type { RouteExport } from './models';
-/**
- * This variable reference is replaced with a glob of all page routes.
- */
-export declare const ANALOG_ROUTE_FILES: {};
-/**
- * This variable reference is replaced with a glob of all content routes.
- */
-export declare const ANALOG_CONTENT_ROUTE_FILES: {};
-export type Files = Record<string, () => Promise<RouteExport | string>>;
+import { type Files } from './route-files';
 /**
  * A function used to parse list of files and create configuration of routes.
  *
@@ -16,4 +7,5 @@ export type Files = Record<string, () => Promise<RouteExport | string>>;
  * @returns Array of routes
  */
 export declare function createRoutes(files: Files, debug?: boolean): Route[];
+export { ANALOG_ROUTE_FILES } from './route-files';
 export declare const routes: Route[];

package/types/src/lib/validation-errors.d.ts

@@ -0,0 +1,7 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+export type ValidationFieldErrors = Record<string, string[]>;
+export declare function issuePathToFieldName(path: ReadonlyArray<string | number | symbol | {
+    key: string | number | symbol;
+}>): string;
+export declare function issuesToFieldErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>): ValidationFieldErrors;
+export declare function issuesToFormErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>): string[];

package/types/tanstack-query/server/src/define-page-load-queries.d.ts

@@ -0,0 +1,66 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { QueryClient } from '@tanstack/angular-query-experimental';
+import type { DehydratedState } from '@tanstack/angular-query-experimental';
+import type { H3Event, H3EventContext } from 'nitro/h3';
+import type { $Fetch } from 'nitro/types';
+import { type PageLoadContext } from '../../../server/actions/src/index.js';
+export { ANALOG_QUERIES_KEY } from '../../src/constants.js';
+type NodeContext = NonNullable<H3Event['node']>;
+type OptionalSchema = StandardSchemaV1 | undefined;
+export interface PageLoadQueriesResult<TData> {
+    __analogQueries: DehydratedState;
+    data: TData;
+}
+export interface DefinePageLoadQueriesOptions<TParamsSchema extends OptionalSchema, TQuerySchema extends OptionalSchema, TData> {
+    params?: TParamsSchema;
+    query?: TQuerySchema;
+    /**
+     * Optional QueryClient factory. Defaults to `new QueryClient()`.
+     * Override to set `defaultOptions` (e.g. `queries: { staleTime: Infinity }`).
+     */
+    client?: () => QueryClient;
+    /**
+     * Handler receives the standard PageLoadContext plus a per-request
+     * QueryClient. Use `client.prefetchQuery` / `ensureQueryData` /
+     * `prefetchInfiniteQuery` to warm the cache; the dehydrated client
+     * is returned as `__analogQueries` on the load result. Anything you
+     * return from the handler becomes `data` on the same result.
+     */
+    handler: (ctx: PageLoadContext<TParamsSchema, TQuerySchema> & {
+        client: QueryClient;
+    }) => Promise<TData> | TData;
+}
+/**
+ * Page load helper that prefetches TanStack Query queries inside the
+ * `.server.ts` handler and ships the dehydrated cache alongside any
+ * additional data. The router-side hydrator in `provideAnalogQuery()`
+ * merges the dehydrated payload into the active `QueryClient` on
+ * `ResolveEnd`, so components reading the same query options see a
+ * warm cache on first render.
+ *
+ * @example
+ * ```ts
+ * // src/app/pages/posts.server.ts
+ * import { definePageLoadQueries } from '@analogjs/router/tanstack-query/server';
+ * import { queryOptions } from '@tanstack/angular-query-experimental';
+ *
+ * export const postsQuery = queryOptions({
+ *   queryKey: ['posts'],
+ *   queryFn: async ({ signal }) =>
+ *     fetch('https://api.example.com/posts', { signal }).then((r) => r.json()),
+ * });
+ *
+ * export const load = definePageLoadQueries({
+ *   handler: async ({ client }) => {
+ *     await client.prefetchQuery(postsQuery);
+ *   },
+ * });
+ * ```
+ */
+export declare function definePageLoadQueries<TParamsSchema extends OptionalSchema = undefined, TQuerySchema extends OptionalSchema = undefined, TData = void>(options: DefinePageLoadQueriesOptions<TParamsSchema, TQuerySchema, TData>): (ctx: {
+    params: H3EventContext['params'];
+    req: NodeContext['req'];
+    res: NonNullable<NodeContext['res']>;
+    fetch: $Fetch;
+    event: H3Event;
+}) => Promise<PageLoadQueriesResult<TData> | Response>;

package/types/tanstack-query/server/src/index.d.ts

@@ -0,0 +1,3 @@
+export { provideServerAnalogQuery } from '../../src/provide-server-analog-query';
+export { definePageLoadQueries, ANALOG_QUERIES_KEY, } from './define-page-load-queries';
+export type { PageLoadQueriesResult, DefinePageLoadQueriesOptions, } from './define-page-load-queries';

package/types/tanstack-query/src/constants.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Route-data key under `ActivatedRoute.data['load']` that holds the
+ * `DehydratedState` produced by `definePageLoadQueries`. The Router-
+ * events hydrator in `provideAnalogQuery()` looks for this key on
+ * `ResolveEnd` and merges the dehydrated payload into the active
+ * `QueryClient`, so component-issued queries hit a warm cache on
+ * first render.
+ */
+export declare const ANALOG_QUERIES_KEY: '__analogQueries';

package/types/tanstack-query/src/index.d.ts

@@ -0,0 +1,2 @@
+export { ANALOG_QUERY_STATE_KEY, provideAnalogQuery, } from './provide-analog-query.js';
+export { serverQueryOptions, serverMutationOptions, serverInfiniteQueryOptions, } from './server-query.js';

package/types/tanstack-query/src/provide-analog-query.d.ts

@@ -0,0 +1,4 @@
+import type { EnvironmentProviders, StateKey } from '@angular/core';
+import type { DehydratedState } from '@tanstack/angular-query-experimental';
+export declare const ANALOG_QUERY_STATE_KEY: StateKey<DehydratedState>;
+export declare function provideAnalogQuery(): EnvironmentProviders;

package/types/tanstack-query/src/provide-server-analog-query.d.ts

@@ -0,0 +1,2 @@
+import type { EnvironmentProviders } from '@angular/core';
+export declare function provideServerAnalogQuery(): EnvironmentProviders;

package/types/tanstack-query/src/server-query.d.ts

@@ -0,0 +1,16 @@
+import type { HttpClient } from '@angular/common/http';
+import type { CreateQueryOptions, CreateMutationOptions, CreateInfiniteQueryOptions, DefaultError, InfiniteData, QueryKey } from '@tanstack/angular-query-experimental';
+import type { ServerRouteHandler, InferRouteQuery, InferRouteBody, InferRouteResult } from '../../server/actions/src/index.js';
+export declare function serverQueryOptions<TRoute extends ServerRouteHandler<any, any, any>, TError = DefaultError, TData = InferRouteResult<TRoute>, TQueryKey extends QueryKey = QueryKey>(http: HttpClient, url: string, options: {
+    queryKey: TQueryKey;
+    query?: InferRouteQuery<TRoute>;
+} & Omit<CreateQueryOptions<InferRouteResult<TRoute>, TError, TData, TQueryKey>, 'queryKey' | 'queryFn'>): CreateQueryOptions<InferRouteResult<TRoute>, TError, TData, TQueryKey>;
+export declare function serverMutationOptions<TRoute extends ServerRouteHandler<any, any, any>, TError = DefaultError, TOnMutateResult = unknown>(http: HttpClient, url: string, options?: Omit<CreateMutationOptions<InferRouteResult<TRoute>, TError, InferRouteBody<TRoute>, TOnMutateResult>, 'mutationFn'>): CreateMutationOptions<InferRouteResult<TRoute>, TError, InferRouteBody<TRoute>, TOnMutateResult>;
+export declare function serverInfiniteQueryOptions<TRoute extends ServerRouteHandler<any, any, any>, TError = DefaultError, TData = InfiniteData<InferRouteResult<TRoute>>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(http: HttpClient, url: string, options: {
+    queryKey: TQueryKey;
+    query: (context: {
+        pageParam: TPageParam;
+    }) => InferRouteQuery<TRoute>;
+    initialPageParam: TPageParam;
+    getNextPageParam: (lastPage: InferRouteResult<TRoute>, allPages: InferRouteResult<TRoute>[]) => TPageParam | undefined | null;
+} & Omit<CreateInfiniteQueryOptions<InferRouteResult<TRoute>, TError, TData, TQueryKey, TPageParam>, 'queryKey' | 'queryFn' | 'initialPageParam' | 'getNextPageParam'>): CreateInfiniteQueryOptions<InferRouteResult<TRoute>, TError, TData, TQueryKey, TPageParam>;

package/types/tokens/src/index.d.ts

@@ -21,3 +21,5 @@ export declare function injectResponse(): ServerResponse | null;
 export declare function injectBaseURL(): string | null;
 export declare function injectInternalServerFetch(): ServerInternalFetch | null;
 export declare function injectAPIPrefix(): string;
+export declare const LOCALE: InjectionToken<string>;
+export declare function injectLocale(): string | null;