@absolutejs/absolute 0.19.0-beta.963 → 0.19.0-beta.965

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

@@ -1,9 +1,8 @@
-export type { AngularPageDefinition, AngularPagePropsOf } from '../../types/angular';
+export type { AngularPagePropsOf } from '../../types/angular';
 export { ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER, buildAbsoluteHttpTransferCacheOptions } from './httpTransferCache';
 export { createDeterministicRandom, DETERMINISTIC_NOW, DETERMINISTIC_RANDOM, DETERMINISTIC_SEED, provideDeterministicEnv } from './deterministicEnv';
-export { defineAngularPage } from './page';
 export { useResource, useSubscription, useTimers } from './composables';
-export type { Observer, Resource, ResourceFetcher, ResourceMutator, ResourceOptions } from './composables';
+export type { Observer, Resource, ResourceFetcher, ResourceMutator, ResourceOptions, ResourceStart } from './composables';
 export { preserveAcrossHmr } from './preserveAcrossHmr';
 export { Island } from './Island.browser';
 export { withPendingTask } from './pendingTask';

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

@@ -1,5 +1,5 @@
 export { useResource } from './useResource';
-export type { Resource, ResourceFetcher, ResourceMutator, ResourceOptions } from './useResource';
+export type { Resource, ResourceFetcher, ResourceMutator, ResourceOptions, ResourceStart } from './useResource';
 export { useSubscription } from './useSubscription';
 export type { Observer } from './useSubscription';
 export { useTimers } from './useTimers';

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

@@ -1,9 +1,23 @@
 import { type Signal } from '@angular/core';
 export type ResourceFetcher<T> = (signal: AbortSignal) => Promise<T>;
+/** Controls the resource's startup behavior.
+ *
+ *  - `'immediate'` (default) — fire the fetcher synchronously at creation;
+ *    `loading()` starts `true`.
+ *  - `'pending'` — don't fire the fetcher yet, but render as if a fetch is
+ *    coming: `loading()` starts `true`. Pair with a manual `refresh()` call
+ *    from `ngOnInit` (or wherever the dependencies become available). Use
+ *    this when the fetcher depends on state set after construction (e.g. a
+ *    route param assigned by the page factory) — it avoids the blank-frame
+ *    flash you'd get from `'idle'`.
+ *  - `'idle'` — don't fire the fetcher and don't pretend you will:
+ *    `loading()` starts `false`. The resource is dormant until `refresh()`
+ *    or `mutate()` is called.
+ */
+export type ResourceStart = 'immediate' | 'pending' | 'idle';
 export type ResourceOptions = {
-    /** Run the fetcher immediately on creation. Default: true. Pass
-     *  `false` to defer the first load until `refresh()` is called. */
-    immediate?: boolean;
+    /** When and how the fetcher fires on creation. Default: `'immediate'`. */
+    start?: ResourceStart;
 };
 export type ResourceMutator<T> = T | null | ((prev: T | null) => T | null);
 export type Resource<T> = {
@@ -11,7 +25,8 @@ export type Resource<T> = {
     data: Signal<T | null>;
     /** Latest rejection reason, or `null` when the resource is healthy. */
     error: Signal<unknown>;
-    /** True while a fetch is in flight. */
+    /** True while a fetch is in flight, or when `start: 'pending'` was set
+     *  and `refresh()` hasn't been called yet. */
     loading: Signal<boolean>;
     /** Re-runs the fetcher. Any in-flight request is aborted first. */
     refresh: () => Promise<void>;

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

@@ -1,11 +1,10 @@
 import '@angular/compiler';
-export type { AngularPageDefinition, AngularPagePropsOf } from '../../types/angular';
+export type { AngularPagePropsOf } from '../../types/angular';
 export { ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER, buildAbsoluteHttpTransferCacheOptions } from './httpTransferCache';
 export { createDeterministicRandom, DETERMINISTIC_NOW, DETERMINISTIC_RANDOM, DETERMINISTIC_SEED, provideDeterministicEnv } from './deterministicEnv';
 export { handleAngularPageRequest } from './pageHandler';
-export { defineAngularPage } from './page';
 export { useResource, useSubscription, useTimers } from './composables';
-export type { Observer, Resource, ResourceFetcher, ResourceMutator, ResourceOptions } from './composables';
+export type { Observer, Resource, ResourceFetcher, ResourceMutator, ResourceOptions, ResourceStart } from './composables';
 export { preserveAcrossHmr } from './preserveAcrossHmr';
 export { withPendingTask } from './pendingTask';
 export { createTypedIsland } from './createIsland';

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

@@ -1,18 +1,14 @@
-import type { AngularPageDefinition, AngularPagePropsOf } from '../../types/angular';
+import type { AngularPagePropsOf } from '../../types/angular';
 import { type StreamingSlotEnhancerOptions } from '../core/responseEnhancers';
 type AngularPageRenderOptions = StreamingSlotEnhancerOptions & {
     collectStreamingSlots?: boolean;
 };
-type IsAny<T> = 0 extends 1 & T ? true : false;
-type HasNoRequiredAngularProps<Props> = IsAny<Props> extends true ? true : keyof Props extends never ? true : false;
-type AngularPageHasOptionalProps<Page> = Page extends {
-    page: AngularPageDefinition<infer Props>;
-} ? HasNoRequiredAngularProps<Props> : Page extends {
-    default: AngularPageDefinition<infer Props>;
-} ? HasNoRequiredAngularProps<Props> : HasNoRequiredAngularProps<AngularPagePropsOf<Page>>;
-export type AngularPageRequestInput<Page = {
-    page: AngularPageDefinition<Record<never, never>>;
-}> = AngularPageRenderOptions & {
+/** True when the derived Props record has no required keys — used to
+ *  flip the `props` argument between required and optional in the
+ *  request-input shape. Pages with no SSR-injected tokens skip
+ *  `props` entirely. */
+type HasNoRequiredAngularProps<Props> = keyof Props extends never ? true : Partial<Props> extends Props ? true : false;
+export type AngularPageRequestInput<Page = unknown> = AngularPageRenderOptions & {
     headTag?: `<head>${string}</head>`;
     indexPath: string;
     pagePath: string;
@@ -30,12 +26,10 @@ export type AngularPageRequestInput<Page = {
      *  honoured. For finer control use `Route.data.sitemap` in the
      *  page's `Routes` config, or `sitemap.overrides` in `absolute.config.ts`. */
     sitemap?: import('../../types/sitemap').PageHandlerSitemapMetadata;
-} & (AngularPageHasOptionalProps<Page> extends true ? {
+} & (HasNoRequiredAngularProps<AngularPagePropsOf<Page>> extends true ? {
     props?: NoInfer<AngularPagePropsOf<Page>>;
 } : {
     props: NoInfer<AngularPagePropsOf<Page>>;
 });
-export declare const handleAngularPageRequest: <Page = {
-    page: AngularPageDefinition<Record<never, never>>;
-}>(input: AngularPageRequestInput<Page>) => Promise<Response>;
+export declare const handleAngularPageRequest: <Page = unknown>(input: AngularPageRequestInput<Page>) => Promise<Response>;
 export {};

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

@@ -1,6 +1,5 @@
-export type { AngularPageDefinition, AngularPagePropsOf } from '../../types/angular';
+export type { AngularPagePropsOf } from '../../types/angular';
 export { ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER, buildAbsoluteHttpTransferCacheOptions } from './httpTransferCache';
 export { createDeterministicRandom, DETERMINISTIC_NOW, DETERMINISTIC_RANDOM, DETERMINISTIC_SEED, provideDeterministicEnv } from './deterministicEnv';
 export { handleAngularPageRequest } from './pageHandler';
-export { defineAngularPage } from './page';
 export { withPendingTask } from './pendingTask';

package/dist/types/angular.d.ts

@@ -16,26 +16,56 @@ export type AngularDeps = {
     SecurityContext: typeof import('@angular/core').SecurityContext;
     withHttpTransferCacheOptions: typeof import('@angular/platform-browser').withHttpTransferCacheOptions;
 };
-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;
+/**
+ * SCREAMING_SNAKE_CASE → camelCase at the type level. Mirrors the
+ * runtime mapping in `ssrRender.ts` that turns a page module's
+ * exported `INITIAL_ACCOUNT` token into the `initialAccount` prop
+ * the backend pages plugin passes.
+ */
+type SnakeToCamel<S extends string> = S extends `${infer First}_${infer Rest}` ? `${Lowercase<First>}${Capitalize<SnakeToCamel<Rest>>}` : Lowercase<S>;
+/** Pull the value type out of `InjectionToken<T>` (loosened to any
+ *  shape that carries the same `T` generic parameter). */
+type ExtractTokenValue<T> = T extends {
+    __NG_ELEMENT_ID__?: unknown;
+    ngMetadataName?: 'InjectionToken';
+    prototype: infer P;
+} ? P : T extends import('@angular/core').InjectionToken<infer U> ? U : never;
+/** Type guard: is `T` an `InjectionToken<unknown>`? Written
+ *  structurally so it picks up both Angular's official type and any
+ *  user-defined token via duck-typing on `prototype`. */
+type IsInjectionToken<T> = T extends import('@angular/core').InjectionToken<unknown> ? true : false;
+/** A token whose value type explicitly includes `undefined` becomes
+ *  an optional prop — call sites can omit it. `null` does not flip
+ *  to optional: callers must still pass the value explicitly, even
+ *  if the value happens to be `null`. */
+type RequiredTokenKey<M, K extends keyof M> = IsInjectionToken<M[K]> extends true ? undefined extends ExtractTokenValue<M[K]> ? never : K & string : never;
+type OptionalTokenKey<M, K extends keyof M> = IsInjectionToken<M[K]> extends true ? undefined extends ExtractTokenValue<M[K]> ? K & string : never : never;
+/**
+ * Derives the props shape a page accepts from its module's exported
+ * `InjectionToken<T>` declarations. The runtime in `ssrRender.ts`
+ * already enforces "each prop must match a token re-exported from
+ * the page module"; this type mirrors that. A token whose `T`
+ * includes `null`/`undefined` becomes an optional prop, otherwise
+ * required.
+ */
+export type ExtractPageProps<M> = {
+    [K in keyof M as SnakeToCamel<RequiredTokenKey<M, K>>]: ExtractTokenValue<M[K]>;
+} & {
+    [K in keyof M as SnakeToCamel<OptionalTokenKey<M, K>>]?: ExtractTokenValue<M[K]>;
 };
-export type AngularPagePropsOf<Page> = Page extends {
-    page: AngularPageDefinition<infer Props>;
-} ? Props : Page extends {
-    default: AngularPageDefinition<infer Props>;
-} ? Props : Record<never, never>;
+/**
+ * Props the framework will resolve for a given page module. Pages
+ * declare their prop surface by exporting `InjectionToken<T>`s — no
+ * wrapper function, no separate props type to maintain.
+ */
+export type AngularPagePropsOf<Page> = ExtractPageProps<Page>;
+/**
+ * Cached render data per route. The `headTag` is captured once when
+ * the page module is registered so subsequent renders skip the
+ * filesystem read.
+ */
 export type CachedRouteData = {
     props: Record<string, unknown> | undefined;
     headTag: `<head>${string}</head>`;
 };
+export {};

package/package.json

@@ -402,5 +402,5 @@
 			]
 		}
 	},
-	"version": "0.19.0-beta.963"
+	"version": "0.19.0-beta.965"
 }

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

@@ -1,5 +0,0 @@
-import type { Type } from '@angular/core';
-import type { AngularPageDefinition } from '../../types/angular';
-export declare const defineAngularPage: <Props extends Record<string, unknown> = Record<never, never>>(definition: {
-    component: Type<unknown>;
-}) => AngularPageDefinition<Props>;