@absolutejs/absolute 0.19.0-beta.952 → 0.19.0-beta.953

package/dist/src/angular/enumerateSpaRoutes.d.ts

@@ -0,0 +1,6 @@
+import type { SpaRouteEntry } from '../utils/spaRouteEnumeration';
+/** Reads the `Routes` arrays captured for any `provideRouter(...)` call
+ *  in `pageModule.providers` (compile-time rewrite records them) and
+ *  walks them, eagerly resolving `loadChildren`. Returns one entry per
+ *  leaf, with paths relative to the page's mount point. */
+export declare const enumerateAngularSpaRoutes: (pageModule: unknown) => Promise<SpaRouteEntry[]>;

package/dist/src/angular/index.d.ts

@@ -4,6 +4,7 @@ export { ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER, buildAbsoluteHttpTransferCach
 export { createDeterministicRandom, DETERMINISTIC_NOW, DETERMINISTIC_RANDOM, DETERMINISTIC_SEED, provideDeterministicEnv } from './deterministicEnv';
 export { handleAngularPageRequest } from './pageHandler';
 export { defineAngularPage } from './page';
+export { __abs_provideRouter } from './internal/captureProvideRouter';
 export { preserveAcrossHmr } from './preserveAcrossHmr';
 export { withPendingTask } from './pendingTask';
 export { createTypedIsland } from './createIsland';

package/dist/src/angular/internal/captureProvideRouter.d.ts

@@ -0,0 +1,11 @@
+import { provideRouter, type Routes } from '@angular/router';
+/** Runtime shim installed by AbsoluteJS's compile-time rewrite. User
+ *  code in Angular pages calls `provideRouter(routes, ...features)`
+ *  as usual; the compile pipeline rewrites those call sites to call
+ *  this wrapper instead, which delegates to the real `provideRouter`
+ *  and records the route table for sitemap enumeration. */
+export declare const __abs_provideRouter: (routes: Routes, ...features: Parameters<typeof provideRouter> extends [Routes, ...infer F] ? F : unknown[]) => unknown;
+/** Look up the `Routes` array captured for a given `EnvironmentProviders`
+ *  entry from `provideRouter`. Returns `undefined` for any other provider
+ *  shape. */
+export declare const getRoutesForProviders: (providers: unknown) => Routes | undefined;

package/dist/src/build/rewriteProvideRouter.d.ts

@@ -0,0 +1,5 @@
+/** Returns the source with `provideRouter(...)` calls rewritten to use
+ *  AbsoluteJS's capturing shim. Idempotent: returns the source unchanged
+ *  when no `@angular/router` import is present or when the shim has
+ *  already been injected. */
+export declare const rewriteAngularProvideRouter: (source: string) => string;

package/dist/src/utils/generateSitemap.d.ts

@@ -1,6 +1,12 @@
 import type { SitemapConfig } from '../../types/sitemap';
-export declare const generateSitemap: (routes: {
+type AppRoute = {
     method: string;
     path: string;
     handler?: unknown;
-}[], serverUrl: string, outDir: string, config?: SitemapConfig) => Promise<void>;
+};
+type AppLike = {
+    routes: AppRoute[];
+    handle: (request: Request) => Promise<Response>;
+};
+export declare const generateSitemap: (app: AppLike, serverUrl: string, outDir: string, config?: SitemapConfig) => Promise<void>;
+export {};

package/dist/src/utils/spaRouteEnumeration.d.ts

@@ -0,0 +1,23 @@
+export type SpaRouteSitemap = 'exclude' | 'include' | {
+    priority?: number;
+    changefreq?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+    lastmod?: string;
+};
+export type SpaRouteEntry = {
+    /** Path relative to the page's mount point (no leading slash needed). */
+    path: string;
+    /** True when any segment is `:param`, `*`, or `**`. */
+    dynamic?: boolean;
+    /** Optional sitemap metadata read off `Route.data.sitemap`. */
+    sitemap?: SpaRouteSitemap;
+};
+/** True when the current async context is collecting SPA routes. Framework
+ *  page handlers should short-circuit their SSR pipeline when this is set
+ *  and instead call `recordSpaRoutes` with the page's enumerated routes. */
+export declare const isCollectingSpaRoutes: () => boolean;
+/** Push enumerated routes into the active collection. No-op when called
+ *  outside a `collectSpaRoutes` scope. */
+export declare const recordSpaRoutes: (entries: SpaRouteEntry[]) => void;
+/** Run `task` with an active SPA-route collection scope and return whatever
+ *  routes were recorded inside it. */
+export declare const collectSpaRoutes: (task: () => Promise<unknown>) => Promise<SpaRouteEntry[]>;

package/dist/types/angular.d.ts

@@ -18,6 +18,15 @@ export type AngularDeps = {
 };
 export type AngularPageDefinition<Props extends Record<string, unknown> = Record<never, never>> = {
     component: import('@angular/core').Type<unknown>;
+    /**
+     * Optional SPA route configuration for this page. When provided,
+     * the sitemap pipeline walks it (eagerly resolving `loadChildren`)
+     * and emits one entry per non-dynamic leaf, prefixed by the
+     * Elysia mount path. Pass the same `Routes` array given to
+     * `provideRouter(...)` so the single source of truth stays in
+     * user code.
+     */
+    routes?: import('@angular/router').Routes;
     /** Type-only marker used by handleAngularPageRequest to infer route props. */
     __absoluteAngularPageProps?: Props;
 };

package/package.json

@@ -401,5 +401,5 @@
 			]
 		}
 	},
-	"version": "0.19.0-beta.952"
+	"version": "0.19.0-beta.953"
 }