@analogjs/router 3.0.0-alpha.2 → 3.0.0-alpha.21

package/types/src/lib/inject-navigate.d.ts

@@ -0,0 +1,23 @@
+import { type NavigationBehaviorOptions } from '@angular/router';
+import type { AnalogRoutePath, RoutePathArgs } from './route-path';
+type NavigateWithExtrasArgs<P extends AnalogRoutePath> = RoutePathArgs<P> extends [options?: infer Options] ? [extras: NavigationBehaviorOptions] | [options: Options | undefined, extras: NavigationBehaviorOptions] : [options: RoutePathArgs<P>[0], extras: NavigationBehaviorOptions];
+type TypedNavigate = {
+    <P extends AnalogRoutePath>(path: P, ...args: RoutePathArgs<P>): Promise<boolean>;
+    <P extends AnalogRoutePath>(path: P, ...args: NavigateWithExtrasArgs<P>): Promise<boolean>;
+};
+/**
+ * Injects a typed navigate function.
+ *
+ * @example
+ * ```ts
+ * const navigate = injectNavigate();
+ *
+ * navigate('/users/[id]', { params: { id: '42' } });   // ✅
+ * navigate('/users/[id]', { params: { id: 42 } });     // ❌ type error
+ *
+ * // With navigation extras
+ * navigate('/users/[id]', { params: { id: '42' } }, { replaceUrl: true });
+ * ```
+ */
+export declare function injectNavigate(): TypedNavigate;
+export {};

package/types/src/lib/inject-route-context.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Injects the root route context provided via `withRouteContext()`.
+ *
+ * Inspired by TanStack Router's context inheritance where
+ * `createRootRouteWithContext<T>()` makes a typed context available
+ * to every route's `beforeLoad` and `loader` callbacks.
+ *
+ * In Angular, this uses DI under the hood — `withRouteContext(ctx)`
+ * provides the value, and `injectRouteContext<T>()` retrieves it
+ * with the expected type.
+ *
+ * @example
+ * ```ts
+ * // app.config.ts
+ * provideFileRouter(
+ *   withRouteContext({
+ *     auth: inject(AuthService),
+ *     analytics: inject(AnalyticsService),
+ *   }),
+ * )
+ *
+ * // any-page.page.ts
+ * const ctx = injectRouteContext<{
+ *   auth: AuthService;
+ *   analytics: AnalyticsService;
+ * }>();
+ * ctx.analytics.trackPageView();
+ * ```
+ *
+ * @experimental
+ */
+export declare function injectRouteContext<T extends Record<string, unknown> = Record<string, unknown>>(): T;

package/types/src/lib/inject-route-endpoint-url.d.ts

@@ -0,0 +1,2 @@
+import type { ActivatedRouteSnapshot } from '@angular/router';
+export declare function injectRouteEndpointURL(route: ActivatedRouteSnapshot): URL;

package/types/src/lib/inject-typed-params.d.ts

@@ -0,0 +1,63 @@
+import { Injector, Signal } from '@angular/core';
+import type { AnalogRoutePath, RouteParamsOutput, RouteQueryOutput } from './route-path';
+/**
+ * Injects typed route params as a signal, constrained by the route table.
+ *
+ * Inspired by TanStack Router's `useParams({ from: '/users/$userId' })`
+ * pattern where the `from` parameter narrows the return type to only
+ * the params defined for that route.
+ *
+ * The `from` parameter is used purely for TypeScript type inference —
+ * at runtime, params are read from the current `ActivatedRoute`. This
+ * means it works correctly when used inside a component rendered by
+ * the specified route.
+ *
+ * When `withTypedRouter({ strictRouteParams: true })` is configured,
+ * a dev-mode assertion checks that the expected params from `from`
+ * exist in the active route and warns on mismatch.
+ *
+ * @example
+ * ```ts
+ * // In a component rendered at /users/[id]
+ * const params = injectParams('/users/[id]');
+ * // params() → { id: string }
+ *
+ * // With schema validation output types
+ * const params = injectParams('/products/[slug]');
+ * // params() → validated output type from routeParamsSchema
+ * ```
+ *
+ * @experimental
+ */
+export declare function injectParams<P extends AnalogRoutePath>(_from: P, options?: {
+    injector?: Injector;
+}): Signal<RouteParamsOutput<P>>;
+/**
+ * Injects typed route query params as a signal, constrained by the
+ * route table.
+ *
+ * Inspired by TanStack Router's `useSearch({ from: '/issues' })` pattern
+ * where search params are validated and typed per-route via
+ * `validateSearch` schemas.
+ *
+ * In Analog, the typing comes from `routeQuerySchema` exports that are
+ * detected at build time and recorded in the generated route table.
+ *
+ * The `from` parameter is used purely for TypeScript type inference.
+ * When `withTypedRouter({ strictRouteParams: true })` is configured,
+ * a dev-mode assertion checks that the expected params from `from`
+ * exist in the active route and warns on mismatch.
+ *
+ * @example
+ * ```ts
+ * // In a component rendered at /issues
+ * // (where routeQuerySchema validates { page: number, status: string })
+ * const query = injectQuery('/issues');
+ * // query() → { page: number; status: string }
+ * ```
+ *
+ * @experimental
+ */
+export declare function injectQuery<P extends AnalogRoutePath>(_from: P, options?: {
+    injector?: Injector;
+}): Signal<RouteQueryOutput<P>>;

package/types/src/lib/json-ld.d.ts

@@ -0,0 +1,31 @@
+import type { Graph, Thing, WithContext } from 'schema-dts';
+export type JsonLdObject = Record<string, unknown>;
+export declare function isJsonLdObject(value: unknown): value is JsonLdObject;
+export declare function normalizeJsonLd(value: unknown): JsonLdObject[];
+export type JsonLd = JsonLdObject | JsonLdObject[];
+/**
+ * Typed JSON-LD document based on `schema-dts`.
+ *
+ * Accepts single Schema.org nodes (`WithContext<Thing>`),
+ * `@graph`-based documents (`Graph`), or arrays of nodes.
+ *
+ * This is the canonical JSON-LD type for route authoring surfaces
+ * (`routeMeta.jsonLd`, `routeJsonLd`, generated manifest).
+ *
+ * @example
+ * ```ts
+ * import type { WebPage, WithContext } from 'schema-dts';
+ *
+ * export const routeMeta = {
+ *   jsonLd: {
+ *     '@context': 'https://schema.org',
+ *     '@type': 'WebPage',
+ *     name: 'Products',
+ *   } satisfies WithContext<WebPage>,
+ * };
+ * ```
+ */
+export type AnalogJsonLdDocument = WithContext<Thing> | Graph | Array<WithContext<Thing>>;
+export declare const ROUTE_JSON_LD_KEY: unique symbol;
+export declare function updateJsonLdOnRouteChange(): void;
+export declare function serializeJsonLd(entry: JsonLdObject): string | null;

package/types/src/lib/meta-tags.d.ts

@@ -0,0 +1,33 @@
+export declare const ROUTE_META_TAGS_KEY: unique symbol;
+declare const CHARSET_KEY = "charset";
+declare const HTTP_EQUIV_KEY = "httpEquiv";
+declare const NAME_KEY = "name";
+declare const PROPERTY_KEY = "property";
+declare const CONTENT_KEY = "content";
+declare const ITEMPROP_KEY = "itemprop";
+export type MetaTag = (CharsetMetaTag & ExcludeRestMetaTagKeys<typeof CHARSET_KEY>) | (HttpEquivMetaTag & ExcludeRestMetaTagKeys<typeof HTTP_EQUIV_KEY>) | (NameMetaTag & ExcludeRestMetaTagKeys<typeof NAME_KEY>) | (PropertyMetaTag & ExcludeRestMetaTagKeys<typeof PROPERTY_KEY>) | (ItempropMetaTag & ExcludeRestMetaTagKeys<typeof ITEMPROP_KEY>);
+type CharsetMetaTag = {
+    [CHARSET_KEY]: string;
+};
+type HttpEquivMetaTag = {
+    [HTTP_EQUIV_KEY]: string;
+    [CONTENT_KEY]: string;
+};
+type NameMetaTag = {
+    [NAME_KEY]: string;
+    [CONTENT_KEY]: string;
+};
+type PropertyMetaTag = {
+    [PROPERTY_KEY]: string;
+    [CONTENT_KEY]: string;
+};
+type ItempropMetaTag = {
+    [ITEMPROP_KEY]: string;
+    [CONTENT_KEY]: string;
+};
+type MetaTagKey = typeof CHARSET_KEY | typeof HTTP_EQUIV_KEY | typeof NAME_KEY | typeof PROPERTY_KEY | typeof ITEMPROP_KEY;
+type ExcludeRestMetaTagKeys<Key extends MetaTagKey> = {
+    [K in Exclude<MetaTagKey, Key>]?: never;
+};
+export declare function updateMetaTagsOnRouteChange(): void;
+export {};

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

@@ -0,0 +1,32 @@
+import { Type } from '@angular/core';
+import { CanActivateChildFn, CanActivateFn, CanDeactivateFn, CanMatchFn, DeprecatedGuard, ResolveFn, Route } from '@angular/router';
+import { defineRouteMeta } from './define-route';
+import { AnalogJsonLdDocument } from './json-ld';
+import { MetaTag } from './meta-tags';
+type OmittedRouteProps = 'path' | 'matcher' | 'component' | 'loadComponent' | 'children' | 'loadChildren' | 'canLoad' | 'outlet';
+export type RouteConfig = Omit<Route, OmittedRouteProps>;
+export interface DefaultRouteMeta extends Omit<Route, OmittedRouteProps | keyof RedirectRouteMeta> {
+    canActivate?: CanActivateFn[] | DeprecatedGuard[];
+    canActivateChild?: CanActivateChildFn[];
+    canDeactivate?: CanDeactivateFn<unknown>[];
+    canMatch?: CanMatchFn[];
+    resolve?: {
+        [key: string | symbol]: ResolveFn<unknown>;
+    };
+    title?: string | ResolveFn<string>;
+    meta?: MetaTag[] | ResolveFn<MetaTag[]>;
+    jsonLd?: AnalogJsonLdDocument | ResolveFn<AnalogJsonLdDocument | undefined>;
+}
+export interface RedirectRouteMeta {
+    redirectTo: string;
+    pathMatch?: Route['pathMatch'];
+}
+export type RouteMeta = (DefaultRouteMeta & {
+    redirectTo?: never;
+}) | RedirectRouteMeta;
+export type RouteExport = {
+    default: Type<unknown>;
+    routeMeta?: RouteMeta | ReturnType<typeof defineRouteMeta>;
+    routeJsonLd?: AnalogJsonLdDocument | ResolveFn<AnalogJsonLdDocument | undefined>;
+};
+export {};

package/types/src/lib/provide-file-router-base.d.ts

@@ -0,0 +1,4 @@
+import { EnvironmentProviders } from '@angular/core';
+import { RouterFeatures, Routes } from '@angular/router';
+export declare function provideFileRouterWithRoutes(...features: RouterFeatures[]): EnvironmentProviders;
+export declare function withExtraRoutes(routes: Routes): RouterFeatures;

package/types/src/lib/provide-file-router.d.ts

@@ -0,0 +1,12 @@
+import { EnvironmentProviders } from '@angular/core';
+import { RouterFeatures } from '@angular/router';
+/**
+ * Sets up providers for the Angular router, and registers
+ * file-based routes. Additional features can be provided
+ * to further configure the behavior of the router.
+ *
+ * @param features
+ * @returns Providers and features to configure the router with routes
+ */
+export declare function provideFileRouter(...features: RouterFeatures[]): EnvironmentProviders;
+export { withExtraRoutes } from './provide-file-router-base';

package/types/src/lib/request-context.d.ts

@@ -0,0 +1,13 @@
+import { HttpEvent, HttpHandlerFn, HttpRequest } from '@angular/common/http';
+import { Observable } from 'rxjs';
+/**
+ * Interceptor that is server-aware when making HttpClient requests.
+ * Server-side requests use the full URL
+ * Prerendering uses the internal Nitro $fetch function, along with state transfer
+ * Client-side requests use the window.location.origin
+ *
+ * @param req HttpRequest<unknown>
+ * @param next HttpHandlerFn
+ * @returns
+ */
+export declare function requestContextInterceptor(req: HttpRequest<unknown>, next: HttpHandlerFn): Observable<HttpEvent<unknown>>;

package/types/src/lib/route-builder.d.ts

@@ -0,0 +1,5 @@
+import type { Route } from '@angular/router';
+import type { RouteExport } from './models';
+export type RouteModuleFactory = () => Promise<RouteExport>;
+export type RouteModuleResolver<TFile> = (filename: string, fileLoader: () => Promise<TFile>) => RouteModuleFactory;
+export declare function createRoutes<TFile>(files: Record<string, () => Promise<TFile>>, resolveModule: RouteModuleResolver<TFile>, debug?: boolean): Route[];

package/types/src/lib/route-config.d.ts

@@ -0,0 +1,2 @@
+import { RouteConfig, RouteMeta } from './models';
+export declare function toRouteConfig(routeMeta: RouteMeta | undefined): RouteConfig;

package/types/src/lib/route-files.d.ts

@@ -0,0 +1,18 @@
+import { InjectionToken } from '@angular/core';
+import type { RouteExport } from './models';
+export type Files = Record<string, () => Promise<RouteExport>>;
+/**
+ * This variable reference is replaced with a glob of all page routes.
+ */
+export declare const ANALOG_ROUTE_FILES: {};
+export interface ExtraRouteFileSource {
+    files: Record<string, () => Promise<unknown>>;
+    resolveModule: (filename: string, fileLoader: () => Promise<unknown>) => () => Promise<RouteExport>;
+}
+export declare const ANALOG_EXTRA_ROUTE_FILE_SOURCES: InjectionToken<ExtraRouteFileSource[]>;
+/**
+ * Replaced at build time by the Vite router plugin with the number of
+ * discovered content route files. Used in dev mode to warn when content
+ * files exist but `withContentRoutes()` is not configured.
+ */
+export declare const ANALOG_CONTENT_FILE_COUNT = 0;

package/types/src/lib/route-path.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Typed route path utilities for Analog.
+ *
+ * This module provides:
+ * - The `AnalogRouteTable` base interface (augmented by generated code)
+ * - The `AnalogRoutePath` union type
+ * - The `routePath()` URL builder function
+ *
+ * No Angular dependencies — can be used in any context.
+ */
+/**
+ * Base interface for the typed route table.
+ *
+ * This interface is augmented by generated code in `src/routeTree.gen.ts`.
+ * When no routes are generated, it is empty and `AnalogRoutePath` falls
+ * back to `string`.
+ */
+export interface AnalogRouteTable {
+}
+/**
+ * Union of all valid route paths.
+ *
+ * When routes are generated, this is a string literal union.
+ * When no routes are generated, this falls back to `string`.
+ */
+export type AnalogRoutePath = keyof AnalogRouteTable extends never ? string : Extract<keyof AnalogRouteTable, string>;
+/**
+ * Options for building a route URL.
+ */
+export interface RoutePathOptionsBase {
+    params?: Record<string, string | string[] | undefined>;
+    query?: Record<string, string | string[] | undefined>;
+    hash?: string;
+}
+/**
+ * Extracts the validated output type for route params.
+ *
+ * When a route exports `routeParamsSchema`, this resolves to the schema's
+ * output type (e.g., `{ id: number }` after coercion).
+ * When no schema exists, this is the same as the navigation param type.
+ */
+export type RouteParamsOutput<P extends string> = P extends keyof AnalogRouteTable ? AnalogRouteTable[P] extends {
+    paramsOutput: infer O;
+} ? O : AnalogRouteTable[P] extends {
+    params: infer Params;
+} ? Params : Record<string, unknown> : Record<string, unknown>;
+/**
+ * Extracts the validated output type for route query params.
+ */
+export type RouteQueryOutput<P extends string> = P extends keyof AnalogRouteTable ? AnalogRouteTable[P] extends {
+    queryOutput: infer O;
+} ? O : Record<string, string | string[] | undefined> : Record<string, string | string[] | undefined>;
+type RequiredRouteParamKeys<Params> = Params extends Record<string, never> ? never : {
+    [K in keyof Params]-?: Record<string, never> extends Pick<Params, K> ? never : K;
+}[keyof Params];
+type HasRequiredRouteParams<Params> = [RequiredRouteParamKeys<Params>] extends [
+    never
+] ? false : true;
+/**
+ * Typed options that infer params from the route table when available.
+ */
+export type RoutePathOptions<P extends string = string> = P extends keyof AnalogRouteTable ? AnalogRouteTable[P] extends {
+    params: infer Params;
+} ? Params extends Record<string, never> ? {
+    query?: RouteQueryOutput<P>;
+    hash?: string;
+} : HasRequiredRouteParams<Params> extends true ? {
+    params: Params;
+    query?: RouteQueryOutput<P>;
+    hash?: string;
+} : {
+    params?: Params;
+    query?: RouteQueryOutput<P>;
+    hash?: string;
+} : RoutePathOptionsBase : RoutePathOptionsBase;
+/**
+ * Conditional args: require options when the route has params.
+ */
+export type RoutePathArgs<P extends string = string> = P extends keyof AnalogRouteTable ? AnalogRouteTable[P] extends {
+    params: infer Params;
+} ? Params extends Record<string, never> ? [options?: RoutePathOptions<P>] : HasRequiredRouteParams<Params> extends true ? [options: RoutePathOptions<P>] : [options?: RoutePathOptions<P>] : [options?: RoutePathOptionsBase] : [options?: RoutePathOptionsBase];
+/**
+ * Result of `routePath()` — contains properties that map directly
+ * to Angular's `[routerLink]`, `[queryParams]`, and `[fragment]` inputs.
+ */
+export interface RouteLinkResult {
+    path: string;
+    queryParams: Record<string, string | string[]> | null;
+    fragment: string | undefined;
+}
+/**
+ * Builds a typed route link object from a route path pattern and options.
+ *
+ * The returned object separates path, query params, and fragment for
+ * direct use with Angular's routerLink directive inputs.
+ *
+ * @example
+ * routePath('/about')
+ * // → { path: '/about', queryParams: null, fragment: undefined }
+ *
+ * routePath('/users/[id]', { params: { id: '42' } })
+ * // → { path: '/users/42', queryParams: null, fragment: undefined }
+ *
+ * routePath('/users/[id]', { params: { id: '42' }, query: { tab: 'settings' }, hash: 'bio' })
+ * // → { path: '/users/42', queryParams: { tab: 'settings' }, fragment: 'bio' }
+ *
+ * @example Template usage
+ * ```html
+ * @let link = routePath('/users/[id]', { params: { id: userId } });
+ * <a [routerLink]="link.path" [queryParams]="link.queryParams" [fragment]="link.fragment">
+ * ```
+ */
+export declare function routePath<P extends AnalogRoutePath>(path: P, ...args: RoutePathArgs<P>): RouteLinkResult;
+/**
+ * Internal: builds a `RouteLinkResult` from path and options.
+ * Exported for direct use in tests (avoids generic constraints).
+ */
+export declare function buildRouteLink(path: string, options?: RoutePathOptionsBase): RouteLinkResult;
+/**
+ * Internal URL builder. Separated from `routePath` so it can be
+ * used without generic constraints (e.g., in `injectNavigate`).
+ */
+export declare function buildUrl(path: string, options?: RoutePathOptionsBase): string;
+export {};

package/types/src/lib/route-types.d.ts

@@ -0,0 +1,12 @@
+import type { H3Event, H3EventContext } from 'nitro/h3';
+import type { $Fetch } from 'nitro/types';
+export type NodeContext = NonNullable<H3Event['node']>;
+export type PageServerLoad = {
+    params: H3EventContext['params'];
+    req: NodeContext['req'];
+    res: NonNullable<NodeContext['res']>;
+    fetch: $Fetch;
+    event: H3Event;
+};
+export type LoadResult<A extends (pageServerLoad: PageServerLoad) => Promise<unknown>> = Awaited<ReturnType<A>>;
+export type LoadDataResult<A extends (pageServerLoad: PageServerLoad) => Promise<unknown>> = Exclude<LoadResult<A>, Response>;

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

@@ -0,0 +1,11 @@
+import type { Route } from '@angular/router';
+import { type Files } from './route-files';
+/**
+ * A function used to parse list of files and create configuration of routes.
+ *
+ * @param files
+ * @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/server.component.d.ts

@@ -0,0 +1,33 @@
+import { InputSignal, OutputEmitterRef, WritableSignal } from '@angular/core';
+import { SafeHtml } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+type ServerProps = Record<string, any>;
+type ServerOutputs = Record<string, any>;
+/**
+ * @description
+ * Component that defines the bridge between the client and server-only
+ * components. The component passes the component ID and props to the server
+ * and retrieves the rendered HTML and outputs from the server-only component.
+ *
+ * Status: experimental
+ */
+export declare class ServerOnly {
+    component: InputSignal<string>;
+    props: InputSignal<ServerProps | undefined>;
+    outputs: OutputEmitterRef<ServerOutputs>;
+    private http;
+    private sanitizer;
+    protected content: WritableSignal<SafeHtml>;
+    private route;
+    private baseURL;
+    private transferState;
+    constructor();
+    updateContent(content: {
+        html: string;
+        outputs: ServerOutputs;
+    }): void;
+    getComponentUrl(componentId: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ServerOnly, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ServerOnly, "server-only,ServerOnly,Server", never, { "component": { "alias": "component"; "required": true; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; }, { "outputs": "outputs"; }, never, never, true, never>;
+}
+export {};

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/index.d.ts

@@ -0,0 +1 @@
+export { provideServerAnalogQuery } from '../../src/provide-server-analog-query';

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 '@analogjs/router/server/actions';
+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

@@ -0,0 +1,23 @@
+import { InjectionToken } from '@angular/core';
+import type { $Fetch } from 'nitro/types';
+import type { IncomingMessage, ServerResponse as NodeServerResponse } from 'node:http';
+export type ServerRequest = IncomingMessage & {
+    originalUrl: string;
+};
+export type ServerResponse = NodeServerResponse;
+export type ServerInternalFetch = $Fetch;
+export type ServerContext = {
+    req: ServerRequest;
+    res: ServerResponse;
+    fetch?: ServerInternalFetch;
+};
+export declare const REQUEST: InjectionToken<ServerRequest>;
+export declare const RESPONSE: InjectionToken<ServerResponse>;
+export declare const BASE_URL: InjectionToken<string>;
+export declare const INTERNAL_FETCH: InjectionToken<ServerInternalFetch>;
+export declare const API_PREFIX: InjectionToken<string>;
+export declare function injectRequest(): ServerRequest | null;
+export declare function injectResponse(): ServerResponse | null;
+export declare function injectBaseURL(): string | null;
+export declare function injectInternalServerFetch(): ServerInternalFetch | null;
+export declare function injectAPIPrefix(): string;

package/fesm2022/analogjs-router-debug.page-jzggTA45.mjs

@@ -1,91 +0,0 @@
-import * as i0 from '@angular/core';
-import { Component } from '@angular/core';
-import { injectDebugRoutes } from './analogjs-router.mjs';
-
-class DebugRoutesComponent {
-    constructor() {
-        this.collectedRoutes = [];
-        this.debugRoutes = injectDebugRoutes();
-    }
-    ngOnInit() {
-        this.traverseRoutes(this.debugRoutes);
-    }
-    traverseRoutes(routes, parent) {
-        routes.forEach((route) => {
-            this.collectedRoutes.push({
-                path: route.isLayout
-                    ? `${parent ? `/${parent}` : ''}${route.path ? `/${route.path}` : ''}`
-                    : `${parent ? `/${parent}` : ''}${route.path ? `/${route.path}` : '/'}`,
-                filename: route.filename,
-                file: route.filename?.replace(/(^.*)pages\//, '') || '',
-                isLayout: route.isLayout,
-            });
-            if (route.children) {
-                const parentSegments = [parent, route.path];
-                const fullParentPath = parentSegments.filter((s) => !!s).join('/');
-                this.traverseRoutes(route.children, fullParentPath);
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: DebugRoutesComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.1.1", type: DebugRoutesComponent, isStandalone: true, selector: "analogjs-debug-routes-page", ngImport: i0, template: `
-    <h2>Routes</h2>
-
-    <div class="table-container">
-      <div class="table-header">
-        <div class="header-cell">Route Path</div>
-        <div class="header-cell">File</div>
-        <div class="header-cell">Type</div>
-      </div>
-      <div class="table-body">
-        @for (
-          collectedRoute of collectedRoutes;
-          track collectedRoute.filename
-        ) {
-          <div class="table-row">
-            <div class="table-cell">{{ collectedRoute.path }}</div>
-            <div class="table-cell" [title]="collectedRoute.filename">
-              {{ collectedRoute.file }}
-            </div>
-            <div class="table-cell">
-              {{ collectedRoute.isLayout ? 'Layout' : 'Page' }}
-            </div>
-          </div>
-        }
-      </div>
-    </div>
-  `, isInline: true, styles: [":host{width:100%}.table-container{width:100%;max-width:900px;margin:0 auto;background:#fff;border-radius:8px;box-shadow:0 2px 4px #0000001a;overflow:hidden}.table-header{display:grid;grid-template-columns:repeat(3,1fr);background:gray;border-bottom:2px solid #e5e7eb}.header-cell{padding:16px 24px;font-weight:600;text-transform:uppercase;font-size:14px;letter-spacing:.05em;color:#fff}.table-body{display:flex;flex-direction:column}.table-row{display:grid;grid-template-columns:repeat(3,1fr);border-bottom:1px solid #e5e7eb;transition:background-color .2s ease}.table-row:last-child{border-bottom:none}.table-row:hover{background-color:#f9fafb}.table-cell{padding:16px 24px;font-size:16px;color:#4b5563}@media(max-width:640px){.table-container{border-radius:0;margin:0}.header-cell,.table-cell{padding:12px 16px}}\n"] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: DebugRoutesComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'analogjs-debug-routes-page', standalone: true, template: `
-    <h2>Routes</h2>
-
-    <div class="table-container">
-      <div class="table-header">
-        <div class="header-cell">Route Path</div>
-        <div class="header-cell">File</div>
-        <div class="header-cell">Type</div>
-      </div>
-      <div class="table-body">
-        @for (
-          collectedRoute of collectedRoutes;
-          track collectedRoute.filename
-        ) {
-          <div class="table-row">
-            <div class="table-cell">{{ collectedRoute.path }}</div>
-            <div class="table-cell" [title]="collectedRoute.filename">
-              {{ collectedRoute.file }}
-            </div>
-            <div class="table-cell">
-              {{ collectedRoute.isLayout ? 'Layout' : 'Page' }}
-            </div>
-          </div>
-        }
-      </div>
-    </div>
-  `, styles: [":host{width:100%}.table-container{width:100%;max-width:900px;margin:0 auto;background:#fff;border-radius:8px;box-shadow:0 2px 4px #0000001a;overflow:hidden}.table-header{display:grid;grid-template-columns:repeat(3,1fr);background:gray;border-bottom:2px solid #e5e7eb}.header-cell{padding:16px 24px;font-weight:600;text-transform:uppercase;font-size:14px;letter-spacing:.05em;color:#fff}.table-body{display:flex;flex-direction:column}.table-row{display:grid;grid-template-columns:repeat(3,1fr);border-bottom:1px solid #e5e7eb;transition:background-color .2s ease}.table-row:last-child{border-bottom:none}.table-row:hover{background-color:#f9fafb}.table-cell{padding:16px 24px;font-size:16px;color:#4b5563}@media(max-width:640px){.table-container{border-radius:0;margin:0}.header-cell,.table-cell{padding:12px 16px}}\n"] }]
-        }] });
-
-export { DebugRoutesComponent as default };
-//# sourceMappingURL=analogjs-router-debug.page-jzggTA45.mjs.map