@absolutejs/absolute 0.19.0-beta.967 → 0.19.0-beta.969

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

@@ -0,0 +1,3 @@
+import type { AngularRouteMount } from '../../types/angular';
+export declare const loadAngularRouteMounts: () => Promise<AngularRouteMount[]>;
+export declare const matchAngularBasePath: (mounts: AngularRouteMount[], urlPath: string) => string;

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

@@ -1,3 +1,4 @@
+import type { EnvironmentProviders, Provider } from '@angular/core';
 import { type StreamingSlotEnhancerOptions } from '../core/responseEnhancers';
 type AngularPageRenderOptions = StreamingSlotEnhancerOptions & {
     collectStreamingSlots?: boolean;
@@ -18,6 +19,14 @@ export type AngularPageRequestInput<Ctx = unknown> = AngularPageRenderOptions &
     request?: Request;
     /** Mutable response init made available through Angular's RESPONSE_INIT token. */
     responseInit?: ResponseInit;
+    /** Page-level Angular providers — `appProviders` for the typical case,
+     *  `[...appProviders, provideRouter(routes)]` for sub-router pages, etc.
+     *  These flow into `bootstrapApplication` at SSR. The framework's
+     *  build pass (`runAngularHandlerScan`) reads the same expression
+     *  via static AST analysis and emits a matching providers module the
+     *  client bundle imports, so SSR and client bootstrap with identical
+     *  DI trees without the page module exporting `providers`. */
+    providers?: ReadonlyArray<Provider | EnvironmentProviders>;
     /** Sitemap metadata for this route. Statically read from the handler
      *  source at registration time, so only literal-object values are
      *  honoured. For finer control use `Route.data.sitemap` in the

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

@@ -0,0 +1,19 @@
+import type { AngularHandlerCall } from './scanAngularHandlerCalls';
+import { type AngularPageRoutes } from './scanAngularPageRoutes';
+export type EmittedProvidersFile = {
+    manifestKey: string;
+    /** Absolute path to the emitted file. */
+    outputPath: string;
+    /** The mount path (e.g. `/portal/`) the generated file derived
+     *  APP_BASE_HREF from, or null when the call wasn't inside a
+     *  sub-router route. */
+    basePath: string | null;
+    /** `true` when the call carried a `providers:` argument. */
+    hasProviders: boolean;
+};
+export declare const emitAngularProvidersFiles: (projectRoot: string, calls: AngularHandlerCall[], pageRoutes: AngularPageRoutes[]) => EmittedProvidersFile[];
+/** Absolute path of the directory the emitter writes to. Exposed so other
+ *  build steps (`compileAngular`'s client wrapper, the SSR `pageHandler`)
+ *  can compute relative paths to the generated files without hard-coding
+ *  the convention. */
+export declare const getProvidersOutputDir: (projectRoot: string) => string;

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

@@ -0,0 +1,3 @@
+import type { AngularHandlerCall } from './scanAngularHandlerCalls';
+export declare const getRouteMountsOutputPath: (projectRoot: string) => string;
+export declare const emitAngularRouteMounts: (projectRoot: string, calls: AngularHandlerCall[]) => string;

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

@@ -0,0 +1,12 @@
+import { type EmittedProvidersFile } from './emitAngularProvidersFiles';
+import { type AngularHandlerCall } from './scanAngularHandlerCalls';
+import { type AngularPageRoutes } from './scanAngularPageRoutes';
+export type AngularHandlerScanResult = {
+    calls: AngularHandlerCall[];
+    pageRoutes: AngularPageRoutes[];
+    providersFiles: EmittedProvidersFile[];
+    /** Set of manifest keys that have a generated providers file the
+     *  client bundle can import. */
+    manifestKeysWithProviders: Set<string>;
+};
+export declare const runAngularHandlerScan: (projectRoot: string, angularDirectory: string) => AngularHandlerScanResult;

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

@@ -0,0 +1,35 @@
+export type ImportSpec = {
+    /** Local name as used inside the providers expression. */
+    localName: string;
+    /** Original exported name (matches localName unless the source used `as`). */
+    importedName: string;
+    /** `true` when the import was a default import (`import foo from "..."`). */
+    isDefault: boolean;
+    /** Module specifier as written in the source — could be a bare package
+     *  name (`@angular/router`) or a path (`./foo`, `../../utils/x`). The
+     *  path forms are resolved to absolute file paths by `resolvedAbsPath`. */
+    source: string;
+    /** Absolute path the source resolves to, or `null` for bare specifiers
+     *  (`@angular/router`, `firebase/auth`, …) which the generated file
+     *  will re-import by the same bare specifier. */
+    resolvedAbsPath: string | null;
+};
+export type AngularHandlerCall = {
+    /** File the call lives in. */
+    sourceFile: string;
+    /** Manifest key extracted from `pagePath: asset(manifest, "Foo")`. */
+    manifestKey: string;
+    /** Verbatim source text of the `providers:` argument expression, or
+     *  `null` if the call didn't include one. */
+    providersExpr: string | null;
+    /** Imports from the source file that the `providers:` expression refers
+     *  to. Empty array when `providersExpr` is null. */
+    providerImports: ImportSpec[];
+    /** Mount path from the surrounding `.get("/path", ...)` / `.post(...)`
+     *  Elysia chain. `null` when the call isn't directly inside such a
+     *  registration (rare but possible — e.g. inside a helper function). */
+    mountPath: string | null;
+};
+/** Walk every TypeScript file under `projectRoot` and return all
+ *  `handleAngularPageRequest({...})` calls found. */
+export declare const scanAngularHandlerCalls: (projectRoot: string) => AngularHandlerCall[];

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

@@ -0,0 +1,14 @@
+export type AngularPageRoutes = {
+    /** Absolute path of the page module. */
+    pageFile: string;
+    /** Manifest key (PascalCase of basename) — `home/home.ts` → `Home`. */
+    manifestKey: string;
+    /** True when the page module top-level declares
+     *  `export const routes` (or `let`/`var`). */
+    hasRoutes: boolean;
+};
+export declare const scanAngularPageRoutes: (pagesRoot: string) => AngularPageRoutes[];
+/** Path the emitter uses as the import source for the page's routes —
+ *  relative from the generated providers file (under
+ *  `.absolutejs/generated/angular/providers/`) back to the page module. */
+export declare const relativeRoutesImport: (emittedFromDir: string, pageFile: string) => string;

package/dist/types/angular.d.ts

@@ -27,3 +27,14 @@ export type CachedRouteData = {
     requestContext: unknown;
     headTag: `<head>${string}</head>`;
 };
+/**
+ * One entry in the build-emitted route-mounts map. The SSR handler
+ * tests each request URL against `pattern` and uses the matching
+ * `basePath` as `APP_BASE_HREF` so sub-router pages (mounted at
+ * `/portal/*`, `/admin/*`, etc.) get the right router base without
+ * the page explicitly overriding it.
+ */
+export type AngularRouteMount = {
+    pattern: RegExp;
+    basePath: string;
+};

package/package.json

@@ -402,5 +402,5 @@
 			]
 		}
 	},
-	"version": "0.19.0-beta.967"
+	"version": "0.19.0-beta.969"
 }