@absolutejs/absolute 0.19.0-beta.984 → 0.19.0-beta.985

package/dist/src/angular/composables/useSubscription.d.ts

@@ -11,12 +11,19 @@ export type Observer<T> = {
  *  collapsed into one call so consumers can't forget the cleanup
  *  operator (the most common Angular memory-leak source).
  *
- *  Prefer calling from an injection context (field initializer or
- *  constructor). When called outside one — e.g. from `ngOnInit` —
- *  pass the host's `DestroyRef` explicitly as the third argument
- *  (capture it via `destroyRef = inject(DestroyRef)` in a field
- *  initializer once). Otherwise auto-teardown is dropped and the
- *  caller owns the returned `Subscription`.
+ *  `inject(DestroyRef)` is only legal in an Angular injection context
+ *  (constructor, field initializer, factory,
+ *  `runInInjectionContext`). Calling `useSubscription` without a
+ *  captured `DestroyRef` from `ngOnInit` or any other lifecycle hook
+ *  will throw `NG0203`. For those call sites, capture the ref once in
+ *  a field initializer (`private destroyRef = inject(DestroyRef);`)
+ *  and pass it as the third argument:
+ *
+ *  ```ts
+ *  ngOnInit() {
+ *    useSubscription(this.events$, (event) => { ... }, this.destroyRef);
+ *  }
+ *  ```
  *
  *  Note: this composable handles teardown only — it does not trigger
  *  change detection on emissions. If the observer mutates state that

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

@@ -19,13 +19,20 @@ 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`. */
+    /** Extra per-request providers merged in on top of the page
+     *  module's bundled providers (`appProviders` + `provideRouter` +
+     *  `APP_BASE_HREF`) at SSR bootstrap. Use for handler-scoped DI
+     *  values that depend on the request — e.g. a tenant-specific
+     *  feature-flag service, a per-request HTTP interceptor token,
+     *  or test-only overrides. The same Angular module instance is
+     *  shared (the backend resolves `@angular/core` through the same
+     *  `node_modules` Bun cache key as the rebuilt page bundle), so
+     *  tokens declared here interop with the bundled providers.
+     *
+     *  **SSR-only.** The browser bundle doesn't see these — the
+     *  client picks up only the providers baked into the page
+     *  module. If the same provider must run on both sides, add it
+     *  to `absolute.config.ts > angular.providers` instead. */
     providers?: ReadonlyArray<Provider | EnvironmentProviders>;
     /** Sitemap metadata for this route. Statically read from the handler
      *  source at registration time, so only literal-object values are

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

@@ -1,30 +1,8 @@
-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). */

package/package.json

@@ -402,5 +402,5 @@
 			]
 		}
 	},
-	"version": "0.19.0-beta.984"
+	"version": "0.19.0-beta.985"
 }