@loozo/angular-router 0.0.3 → 0.0.4

package/types/loozo-angular-router-_generated.d.ts

@@ -1,6 +1,6 @@
 import { ActivatedRouteSnapshot, PartialMatchRouteSnapshot, RedirectFunction, Route, UrlTree } from "@angular/router";
 import { AnyRoute, ParamsOf, SearchOf, UrlValues } from "@loozo/angular-router/_core";
-import { Resource } from "@angular/core";
+import { Signal } from "@angular/core";
 interface RecordBinding {
   readonly definition: () => AnyRoute;
   readonly owners: readonly string[];
@@ -16,7 +16,6 @@ interface Parsed {
   readonly search: Readonly<Record<string, unknown>>;
 }
 interface Job {
-  readonly source: "path" | "search";
   readonly key: string;
   readonly raws: readonly string[];
   readonly array: boolean;
@@ -24,27 +23,39 @@ interface Job {
     parse(raw: string): unknown;
   };
 }
-interface Operation {
-  readonly promise: Promise<Parsed>;
-  outcome: {
-    value: Parsed;
-  } | {
-    error: Error;
-  } | undefined;
-}
 declare function hasIdentity(snapshot: Pick<ActivatedRouteSnapshot, "routeConfig">, id: string): boolean;
 export declare function assertIdentity(snapshot: Pick<ActivatedRouteSnapshot, "routeConfig">, id: string): void;
-declare function inputError(source: "path" | "search", key: string, reason: "missing" | "repeated" | "invalid", cause?: unknown): Error;
-declare function validateRaw(source: "path" | "search", key: string, raws: readonly unknown[], array: boolean): asserts raws is readonly string[];
+declare function validateRaw(key: string, raws: readonly unknown[], array: boolean): asserts raws is readonly string[];
 declare function pathJobs(definition: AnyRoute, url: readonly {
   path: string;
 }[]): Job[];
-declare function searchJobs(definition: AnyRoute, snapshot: Pick<ActivatedRouteSnapshot, "queryParamMap">): Job[];
-declare function runJobs(jobs: readonly Job[]): Promise<Parsed>;
-declare function fullOperation(set: RouteSet, id: string, snapshot: ActivatedRouteSnapshot): Operation;
-export declare function parseInputs(set: RouteSet, id: string, snapshot: ActivatedRouteSnapshot): Promise<Parsed>;
-declare function matchingInputs(set: RouteSet, id: string, snapshot: PartialMatchRouteSnapshot): Promise<Parsed>;
-export declare function callbacks(set: RouteSet, id: string): Pick<Route, "canActivate" | "canActivateChild" | "canMatch" | "resolve">;
+/** Parses prechecked path jobs; the first codec failure is an input error. */
+declare function runPathJobs(jobs: readonly Job[]): Readonly<Record<string, unknown>>;
+/**
+ * Parses a declaration's effective search. It never fails on input: a missing,
+ * repeated or invalid value reads as the key's fallback, or leaves it absent.
+ */
+declare function parseSearch(definition: AnyRoute, snapshot: Pick<ActivatedRouteSnapshot, "queryParamMap">): Readonly<Record<string, unknown>>;
+/** The effective inputs of a complete snapshot, shared by guards, resolvers and handles. */
+export declare function parseInputs(set: RouteSet, id: string, snapshot: ActivatedRouteSnapshot): Parsed;
+/**
+ * Parses a matching candidate's own path params only. Angular passes one partial
+ * snapshot to all of a candidate's canMatch guards, so they share this result.
+ *
+ * @returns An input error when a param is invalid; throws only programming errors.
+ */
+declare function pathInputs(set: RouteSet, id: string, snapshot: PartialMatchRouteSnapshot): {
+  params: Readonly<Record<string, unknown>>;
+} | {
+  error: Error;
+};
+/**
+ * Local path params plus effective search for a candidate's canMatch guards, the
+ * generated one included, or undefined when the path params fail: the generated
+ * guard owns that outcome.
+ */
+declare function matchingInputs(set: RouteSet, id: string, snapshot: PartialMatchRouteSnapshot): Parsed | undefined;
+export declare function callbacks(set: RouteSet, id: string): Pick<Route, "canActivate" | "canActivateChild" | "canMatch" | "resolve" | "title">;
 export declare function redirect(definition: () => AnyRoute): RedirectFunction;
 declare const destinationBrand: unique symbol;
 /**
@@ -63,9 +74,13 @@ declare const destinationBrand: unique symbol;
  */
 export declare class Destination<Target extends AnyRoute, Set = unknown, Id extends string = string> {
   #private;
+  /** Type-only nominal brand carrying the reference's identity; not populated at runtime. */
   readonly [destinationBrand]: {
+    /** Type-only: the referenced route's input and fragment schema. */
     readonly target: Target;
+    /** Type-only: the generator's nominal route-set identity. */
     readonly set: Set;
+    /** Type-only: the exact generated declaration identity. */
     readonly id: Id;
   };
 }
@@ -79,14 +94,16 @@ type IsUnion<Value, Whole = Value> = Value extends unknown ? [Whole] extends [Va
  *
  * @remarks
  * Obtain it in an Angular injection context for the exact generated activated
- * record. Params/search parse together; data contains only local resolver results,
- * not static/ancestor data or title. Resources are native readonly Angular
- * Resources: use hasValue before value access; error-state value reads throw.
+ * record. Params, search and data are readonly Angular Signals of the route's
+ * committed snapshot, with values from the first read. Data contains only local
+ * resolver results, not static/ancestor data or title.
  *
- * Navigation hides old values. Cancellation/same-URL skip restores the survivor
- * without reparsing; obsolete work cannot publish. Relevant parsing participates
- * in Angular stability until publication, error, replacement or destruction.
- * Codecs are not abortable and there is no package timeout or resolved-data cache.
+ * While a navigation is pending, the signals keep the current snapshot's values;
+ * when a navigation commits a new snapshot for this route, all three change
+ * together. Cancellation, failure or a same-URL skip leaves them unchanged. For
+ * pending-navigation UI, read Angular's `Router.currentNavigation()`. There is no
+ * resolved-data cache. Reading params or search throws only when a path codec
+ * rejects a value it accepted while matching, a programming error.
  *
  * Selectors are single known authored literals, not concrete URLs or string
  * unions. `.` is exact-current; other absolute/relative selections use generated
@@ -111,12 +128,12 @@ type IsUnion<Value, Whole = Value> = Value extends unknown ? [Whole] extends [Va
  * ```
  */
 export interface Handle<Target extends AnyRoute, Selected extends Record<string, AnyRoute> = {}, Set = unknown, References extends Record<string, AnyRoute> = {}> {
-  /** Effective positional params; undefined while pending or without a value. */
-  readonly params: Resource<Readonly<ParamsOf<Target>> | undefined>;
-  /** Effective declared search; paired with params from the same parse operation. */
-  readonly search: Resource<Readonly<SearchOf<Target>> | undefined>;
-  /** Own native resolver results only; settles independently of paired inputs. */
-  readonly data: Resource<DataOf<Target> | undefined>;
+  /** Effective positional params of the committed snapshot; kept while a navigation is pending. */
+  readonly params: Signal<Readonly<ParamsOf<Target>>>;
+  /** Effective declared search, from the same snapshot as params; absent keys have no value or fallback. */
+  readonly search: Signal<Readonly<SearchOf<Target>>>;
+  /** Own native resolver results only, from the same snapshot as params. */
+  readonly data: Signal<DataOf<Target>>;
   /**
    * Creates a native UrlTree for this exact declaration without navigating.
    *

package/types/loozo-angular-router.d.ts

@@ -1,2 +1,2 @@
-import { ParamCodec, Route, booleanParam, createUrl, defineRoute, enumParam, nullableSearchParam, numberParam, optionalSearchParam, stringParam } from "@loozo/angular-router/_core";
-export { type ParamCodec, type Route, booleanParam, createUrl, defineRoute, enumParam, nullableSearchParam, numberParam, optionalSearchParam, stringParam };
+import { ParamCodec, Route, booleanParam, createUrl, defineRoute, enumParam, numberParam, stringParam, withFallback } from "@loozo/angular-router/_core";
+export { type ParamCodec, type Route, booleanParam, createUrl, defineRoute, enumParam, numberParam, stringParam, withFallback };