@loozo/angular-router 0.0.2 → 0.0.4

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

@@ -1,27 +1,62 @@
-import { ActivatedRouteSnapshot, Route, RedirectFunction, UrlTree } from '@angular/router';
-import { AnyRoute, ParamsOf, SearchOf, UrlValues } from '@loozo/angular-router/_core';
-import { Resource } from '@angular/core';
-
+import { ActivatedRouteSnapshot, PartialMatchRouteSnapshot, RedirectFunction, Route, UrlTree } from "@angular/router";
+import { AnyRoute, ParamsOf, SearchOf, UrlValues } from "@loozo/angular-router/_core";
+import { Signal } from "@angular/core";
 interface RecordBinding {
-    readonly definition: () => AnyRoute;
-    readonly owners: readonly string[];
+  readonly definition: () => AnyRoute;
+  readonly owners: readonly string[];
 }
 interface RouteSet {
-    readonly records: Readonly<Record<string, RecordBinding>>;
-    readonly destinations: Readonly<Record<string, () => AnyRoute>>;
-    readonly absolute: Readonly<Record<string, string>>;
-    readonly relative: Readonly<Record<string, Readonly<Record<string, string>>>>;
+  readonly records: Readonly<Record<string, RecordBinding>>;
+  readonly destinations: Readonly<Record<string, () => AnyRoute>>;
+  readonly absolute: Readonly<Record<string, string>>;
+  readonly relative: Readonly<Record<string, Readonly<Record<string, string>>>>;
 }
 interface Parsed {
-    readonly params: Readonly<Record<string, unknown>>;
-    readonly search: Readonly<Record<string, unknown>>;
+  readonly params: Readonly<Record<string, unknown>>;
+  readonly search: Readonly<Record<string, unknown>>;
 }
-declare function assertIdentity(snapshot: Pick<ActivatedRouteSnapshot, "routeConfig">, id: string): void;
-declare function parseInputs(set: RouteSet, id: string, snapshot: ActivatedRouteSnapshot): Promise<Parsed>;
-
-declare function callbacks(set: RouteSet, id: string): Pick<Route, "canActivate" | "canActivateChild" | "canMatch" | "resolve">;
-declare function redirect(definition: () => AnyRoute): RedirectFunction;
-
+interface Job {
+  readonly key: string;
+  readonly raws: readonly string[];
+  readonly array: boolean;
+  readonly codec: {
+    parse(raw: string): unknown;
+  };
+}
+declare function hasIdentity(snapshot: Pick<ActivatedRouteSnapshot, "routeConfig">, id: string): boolean;
+export declare function assertIdentity(snapshot: Pick<ActivatedRouteSnapshot, "routeConfig">, id: string): void;
+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[];
+/** 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;
 /**
  * An inert nominal reference exported as `destination` by a route-local facade.
@@ -37,17 +72,21 @@ declare const destinationBrand: unique symbol;
  * @typeParam Set - The generator's nominal route-set identity.
  * @typeParam Id - The exact generated declaration identity.
  */
-declare class Destination<Target extends AnyRoute, Set = unknown, Id extends string = string> {
-    #private;
-    readonly [destinationBrand]: {
-        readonly target: Target;
-        readonly set: Set;
-        readonly id: Id;
-    };
+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;
+  };
 }
-declare function createDestination<Target extends AnyRoute, Set, Id extends string>(getSet: () => RouteSet, id: Id): Destination<Target, Set, Id>;
+export declare function createDestination<Target extends AnyRoute, Set, Id extends string>(getSet: () => RouteSet, id: Id): Destination<Target, Set, Id>;
 type DataOf<Target> = Target extends {
-    readonly __data?: infer Data;
+  readonly __data?: infer Data;
 } ? Readonly<Data> : never;
 type IsUnion<Value, Whole = Value> = Value extends unknown ? [Whole] extends [Value] ? false : true : never;
 /**
@@ -55,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
@@ -86,86 +127,84 @@ type IsUnion<Value, Whole = Value> = Value extends unknown ? [Whole] extends [Va
  * // Bind link to Angular RouterLink, or call route.navigate with the same values.
  * ```
  */
-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>;
-    /**
-     * Creates a native UrlTree for this exact declaration without navigating.
-     *
-     * @param values - Explicit effective params/search and optional own fragment.
-     * @returns Router.parseUrl's result, suitable for Angular RouterLink.
-     * @throws Synchronous URL validation, encoding or stringifier failures before Angular.
-     */
-    link<Keys extends keyof SearchOf<Target> = never>(values: UrlValues<Target, Keys>): UrlTree;
-    /**
-     * Creates a UrlTree for the exact bound declaration, not its pathless winner.
-     *
-     * @param selector - The exact-current literal `.`.
-     * @param values - Explicit values for this declaration, with no current-input reuse.
-     * @returns Router.parseUrl's result without navigating.
-     * @throws Synchronous URL validation, encoding or stringifier failures before Angular.
-     */
-    link<Keys extends keyof SearchOf<Target> = never>(selector: ".", values: UrlValues<Target, Keys>): UrlTree;
-    /**
-     * Creates a UrlTree for a statically admitted absolute/relative authored selector.
-     *
-     * @param selector - A single known template literal, never a concrete URL.
-     * @param values - The selected target's complete explicit values.
-     * @returns Router.parseUrl's result without navigating.
-     * @throws Synchronously for unknown selectors or invalid URL values.
-     */
-    link<const Selector extends keyof Selected & string, Keys extends keyof SearchOf<NoInfer<Selected[Selector]>> = never>(selector: Selector & (IsUnion<Selector> extends true ? never : unknown), values: UrlValues<NoInfer<Selected[Selector]>, Keys>): UrlTree;
-    /**
-     * Creates a UrlTree for a generated reference's own exact declaration.
-     *
-     * @param selector - A genuine destination exported by a facade in this route set.
-     * @param values - The referenced declaration's complete explicit values.
-     * @returns Router.parseUrl's result without navigating.
-     * @throws Synchronously for foreign/fake references or invalid URL values.
-     */
-    link<const Id extends keyof References & string, Keys extends keyof SearchOf<NoInfer<References[Id]>> = never>(selector: Destination<NoInfer<References[Id]>, Set, Id> & (IsUnion<Id> extends true ? never : unknown), values: UrlValues<NoInfer<References[Id]>, Keys>): UrlTree;
-    /**
-     * Navigates to this exact declaration via Router.navigateByUrl.
-     *
-     * @param values - Explicit effective params/search and optional own fragment.
-     * @returns Angular's identical Promise; Angular owns skips, redirects and failures.
-     * @throws Synchronous URL validation, encoding or stringifier failures before Angular.
-     */
-    navigate<Keys extends keyof SearchOf<Target> = never>(values: UrlValues<Target, Keys>): Promise<boolean>;
-    /**
-     * Navigates to the exact bound declaration, not its pathless winner.
-     *
-     * @param selector - The exact-current literal `.`.
-     * @param values - Explicit values for this declaration, with no current-input reuse.
-     * @returns Angular's identical Router.navigateByUrl Promise.
-     * @throws Synchronous URL validation, encoding or stringifier failures before Angular.
-     */
-    navigate<Keys extends keyof SearchOf<Target> = never>(selector: ".", values: UrlValues<Target, Keys>): Promise<boolean>;
-    /**
-     * Navigates to a statically admitted absolute/relative authored selector.
-     *
-     * @param selector - A single known template literal, never a concrete URL.
-     * @param values - The selected target's complete explicit values.
-     * @returns Angular's identical Router.navigateByUrl Promise.
-     * @throws Synchronously for unknown selectors or invalid URL values.
-     */
-    navigate<const Selector extends keyof Selected & string, Keys extends keyof SearchOf<NoInfer<Selected[Selector]>> = never>(selector: Selector & (IsUnion<Selector> extends true ? never : unknown), values: UrlValues<NoInfer<Selected[Selector]>, Keys>): Promise<boolean>;
-    /**
-     * Navigates to a generated reference's own exact declaration.
-     *
-     * @param selector - A genuine destination exported by a facade in this route set.
-     * @param values - The referenced declaration's complete explicit values.
-     * @returns Angular's identical Router.navigateByUrl Promise.
-     * @throws Synchronously for foreign/fake references or invalid URL values.
-     */
-    navigate<const Id extends keyof References & string, Keys extends keyof SearchOf<NoInfer<References[Id]>> = never>(selector: Destination<NoInfer<References[Id]>, Set, Id> & (IsUnion<Id> extends true ? never : unknown), values: UrlValues<NoInfer<References[Id]>, Keys>): Promise<boolean>;
+export interface Handle<Target extends AnyRoute, Selected extends Record<string, AnyRoute> = {}, Set = unknown, References extends Record<string, AnyRoute> = {}> {
+  /** 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.
+   *
+   * @param values - Explicit effective params/search and optional own fragment.
+   * @returns Router.parseUrl's result, suitable for Angular RouterLink.
+   * @throws Synchronous URL validation, encoding or stringifier failures before Angular.
+   */
+  link<Keys extends keyof SearchOf<Target> = never>(values: UrlValues<Target, Keys>): UrlTree;
+  /**
+   * Creates a UrlTree for the exact bound declaration, not its pathless winner.
+   *
+   * @param selector - The exact-current literal `.`.
+   * @param values - Explicit values for this declaration, with no current-input reuse.
+   * @returns Router.parseUrl's result without navigating.
+   * @throws Synchronous URL validation, encoding or stringifier failures before Angular.
+   */
+  link<Keys extends keyof SearchOf<Target> = never>(selector: ".", values: UrlValues<Target, Keys>): UrlTree;
+  /**
+   * Creates a UrlTree for a statically admitted absolute/relative authored selector.
+   *
+   * @param selector - A single known template literal, never a concrete URL.
+   * @param values - The selected target's complete explicit values.
+   * @returns Router.parseUrl's result without navigating.
+   * @throws Synchronously for unknown selectors or invalid URL values.
+   */
+  link<const Selector extends keyof Selected & string, Keys extends keyof SearchOf<NoInfer<Selected[Selector]>> = never>(selector: Selector & (IsUnion<Selector> extends true ? never : unknown), values: UrlValues<NoInfer<Selected[Selector]>, Keys>): UrlTree;
+  /**
+   * Creates a UrlTree for a generated reference's own exact declaration.
+   *
+   * @param selector - A genuine destination exported by a facade in this route set.
+   * @param values - The referenced declaration's complete explicit values.
+   * @returns Router.parseUrl's result without navigating.
+   * @throws Synchronously for foreign/fake references or invalid URL values.
+   */
+  link<const Id extends keyof References & string, Keys extends keyof SearchOf<NoInfer<References[Id]>> = never>(selector: Destination<NoInfer<References[Id]>, Set, Id> & (IsUnion<Id> extends true ? never : unknown), values: UrlValues<NoInfer<References[Id]>, Keys>): UrlTree;
+  /**
+   * Navigates to this exact declaration via Router.navigateByUrl.
+   *
+   * @param values - Explicit effective params/search and optional own fragment.
+   * @returns Angular's identical Promise; Angular owns skips, redirects and failures.
+   * @throws Synchronous URL validation, encoding or stringifier failures before Angular.
+   */
+  navigate<Keys extends keyof SearchOf<Target> = never>(values: UrlValues<Target, Keys>): Promise<boolean>;
+  /**
+   * Navigates to the exact bound declaration, not its pathless winner.
+   *
+   * @param selector - The exact-current literal `.`.
+   * @param values - Explicit values for this declaration, with no current-input reuse.
+   * @returns Angular's identical Router.navigateByUrl Promise.
+   * @throws Synchronous URL validation, encoding or stringifier failures before Angular.
+   */
+  navigate<Keys extends keyof SearchOf<Target> = never>(selector: ".", values: UrlValues<Target, Keys>): Promise<boolean>;
+  /**
+   * Navigates to a statically admitted absolute/relative authored selector.
+   *
+   * @param selector - A single known template literal, never a concrete URL.
+   * @param values - The selected target's complete explicit values.
+   * @returns Angular's identical Router.navigateByUrl Promise.
+   * @throws Synchronously for unknown selectors or invalid URL values.
+   */
+  navigate<const Selector extends keyof Selected & string, Keys extends keyof SearchOf<NoInfer<Selected[Selector]>> = never>(selector: Selector & (IsUnion<Selector> extends true ? never : unknown), values: UrlValues<NoInfer<Selected[Selector]>, Keys>): Promise<boolean>;
+  /**
+   * Navigates to a generated reference's own exact declaration.
+   *
+   * @param selector - A genuine destination exported by a facade in this route set.
+   * @param values - The referenced declaration's complete explicit values.
+   * @returns Angular's identical Router.navigateByUrl Promise.
+   * @throws Synchronously for foreign/fake references or invalid URL values.
+   */
+  navigate<const Id extends keyof References & string, Keys extends keyof SearchOf<NoInfer<References[Id]>> = never>(selector: Destination<NoInfer<References[Id]>, Set, Id> & (IsUnion<Id> extends true ? never : unknown), values: UrlValues<NoInfer<References[Id]>, Keys>): Promise<boolean>;
 }
-declare function nativeOptions(definition: AnyRoute): Record<string, unknown>;
-declare function injectGeneratedRoute<Target extends AnyRoute, Selected extends Record<string, AnyRoute>, Set, References extends Record<string, AnyRoute>>(set: RouteSet, id: string): Handle<Target, Selected, Set, References>;
-
-export { Destination, assertIdentity, callbacks, createDestination, injectGeneratedRoute, nativeOptions, parseInputs, redirect };
-export type { Handle, RecordBinding, RouteSet };
+export declare function nativeOptions(definition: AnyRoute): Record<string, unknown>;
+export declare function injectGeneratedRoute<Target extends AnyRoute, Selected extends Record<string, AnyRoute>, Set, References extends Record<string, AnyRoute>>(set: RouteSet, id: string): Handle<Target, Selected, Set, References>;
+export type { RecordBinding, RouteSet };

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

@@ -1 +1,2 @@
-export { ParamCodec, Route, booleanParam, createUrl, defineRoute, enumParam, nullableSearchParam, numberParam, optionalSearchParam, stringParam } from '@loozo/angular-router/_core';
+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 };

package/.npmignore

@@ -1,3 +0,0 @@
-# Nested package.json's are only needed for development.
-_core/package.json
-_generated/package.json

package/fesm2022/loozo-angular-router.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"loozo-angular-router.mjs","sources":["../../src/index.ts","../../src/loozo-angular-router.ts"],"sourcesContent":["/**\n * Typed declarations, scalar codecs and synchronous URLs for Angular's native router.\n *\n * @remarks\n * Install generated `routes` with Angular's provideRouter and import the colocated\n * `injectRoute`/`destination` facade for typed resources, links and navigation.\n * Generate through the application/serve Architect companions. The `_core` and\n * `_generated` subpaths are internal package/generator coupling, not supported\n * application metadata or graph APIs.\n *\n * @packageDocumentation\n */\nexport {\n  defineRoute,\n  createUrl,\n  stringParam,\n  numberParam,\n  booleanParam,\n  enumParam,\n  optionalSearchParam,\n  nullableSearchParam,\n} from \"@loozo/angular-router/_core\";\nexport type { Route, ParamCodec } from \"@loozo/angular-router/_core\";\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;AAAA;;;;;;;;;;;AAWG;;ACXH;;AAEG"}