@loozo/angular-router 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,185 @@
+import { RedirectCommand, RunGuardsAndResolvers, ActivatedRouteSnapshot, RouterStateSnapshot, MaybeAsync, GuardResult, Route as Route$1, UrlSegment, PartialMatchRouteSnapshot } from '@angular/router';
+import { Observable } from 'rxjs';
+
+interface ParamCodec<Value> {
+    parse(raw: string): Value | Promise<Value>;
+    stringify(value: Value): string;
+}
+declare const searchPresence: unique symbol;
+type OptionalCodec<Value> = ParamCodec<Value | undefined> & {
+    readonly [searchPresence]: "optional";
+};
+type NullableCodec<Value> = ParamCodec<Value | null> & {
+    readonly [searchPresence]: "nullable";
+};
+type PathCodec = ParamCodec<any> & {
+    readonly [searchPresence]?: never;
+};
+type CodecValue<Codec> = Codec extends ParamCodec<infer Value> ? Value : never;
+type IsOptional<Codec> = Codec extends {
+    readonly [searchPresence]: "optional";
+} ? true : false;
+declare function codecPresence(codec: object): "optional" | "nullable" | undefined;
+declare const stringParam: ParamCodec<string>;
+declare const numberParam: ParamCodec<number>;
+declare const booleanParam: ParamCodec<boolean>;
+declare function enumParam<const Values extends readonly string[]>(values: Values): ParamCodec<Values[number]>;
+declare function optionalSearchParam<Value>(codec: ParamCodec<Value>): OptionalCodec<Value>;
+declare function nullableSearchParam<Value>(codec: ParamCodec<Value> & {
+    readonly [searchPresence]?: "nullable";
+}): NullableCodec<Value>;
+
+type ValidName<Name extends string> = Name extends "" | "__proto__" | `...${string}` | `${string}?${string}` | `${string}*${string}` | `${string}[]${string}` ? false : true;
+type SegmentValid<Segment extends string> = Segment extends `$${infer Name}` ? ValidName<Name> : Segment extends "" | "." | ".." | "*" | "**" | `:${string}` ? false : true;
+type ValidateSegments<Path extends string, Scalars extends string = never> = Path extends `${infer Head}/${infer Tail}` ? Head extends `$${string}[]` ? false : SegmentValid<Head> extends true ? ValidateSegments<Tail, Scalars | ScalarName<Head>> : false : Path extends `$${infer Name}[]` ? ValidName<Name> extends true ? Name extends Scalars ? false : true : false : SegmentValid<Path>;
+type ValidPath<Path extends string> = string extends Path ? never : Path extends "" ? Path : ValidateSegments<Path> extends true ? Path : never;
+type ScalarName<Segment extends string> = Segment extends `$${infer Name}` ? Name : never;
+type SegmentName<Segment extends string> = Segment extends `$${infer Name}[]` ? Name : ScalarName<Segment>;
+type PathNames<Path extends string> = Path extends `${infer Head}/${infer Tail}` ? SegmentName<Head> | PathNames<Tail> : SegmentName<Path>;
+type CatchallName<Path extends string> = Path extends `${string}/${infer Tail}` ? CatchallName<Tail> : Path extends `$${infer Name}[]` ? Name : never;
+type Segment = {
+    readonly kind: "static";
+    readonly text: string;
+} | {
+    readonly kind: "scalar" | "catchall";
+    readonly name: string;
+};
+
+declare const routeBrand: unique symbol;
+interface Route<Path extends string, Params, Search, Resolvers = {}, Fragments extends string = string, Catchall extends boolean = CatchallName<Path> extends never ? false : true> {
+    readonly [routeBrand]: {
+        readonly fragments: Fragments;
+        readonly catchall: Catchall;
+    };
+    readonly path: Path;
+    readonly __params?: Params;
+    readonly __search?: Search;
+    readonly __data?: {
+        readonly [Key in keyof Resolvers]: Resolved<Resolvers[Key]>;
+    };
+    readonly resolve?: Readonly<Resolvers>;
+    readonly runGuardsAndResolvers?: RunGuardsAndResolvers;
+}
+type Unwrap<Value> = Value extends Promise<infer Inner> | Observable<infer Inner> ? Unwrap<Inner> : Value;
+type Resolved<Callback> = Callback extends (...args: any[]) => infer Value ? Exclude<Unwrap<Value>, RedirectCommand> : never;
+type AnyRoute = Route<string, any, any, any, any, boolean>;
+type ParamsOf<Target> = Target extends Route<string, infer Params, any, any, any, boolean> ? Params : {};
+type SearchOf<Target> = Target extends Route<string, any, infer Search, any, any, boolean> ? Search : {};
+type FragmentsOf<Target> = Target extends Route<string, any, any, any, infer Fragments, boolean> ? Fragments : never;
+type CodecMap = Record<string, ParamCodec<any>>;
+type LocalParams<Path extends string, Codecs> = {
+    readonly [Key in keyof Codecs]: Key extends CatchallName<Path> ? readonly CodecValue<Codecs[Key]>[] : CodecValue<Codecs[Key]>;
+};
+type SearchValues<Codecs> = {
+    readonly [Key in keyof Codecs as IsOptional<Codecs[Key]> extends true ? never : Key]: CodecValue<Codecs[Key]>;
+} & {
+    readonly [Key in keyof Codecs as IsOptional<Codecs[Key]> extends true ? Key : never]?: CodecValue<Codecs[Key]>;
+};
+type EffectiveParams<Path extends string, Codecs, Parent> = ParamsOf<Parent> & LocalParams<Path, Codecs>;
+type EffectiveSearch<Codecs, Parent> = SearchOf<Parent> & SearchValues<Codecs>;
+type Inputs<Params, Search> = {
+    readonly params: Readonly<Params>;
+    readonly search: Readonly<Search>;
+};
+type Resolver<Params, Search> = (inputs: Inputs<Params, Search>, snapshot: ActivatedRouteSnapshot, state: RouterStateSnapshot) => unknown;
+type ActivationGuard<Params, Search> = (inputs: Inputs<Params, Search>, snapshot: ActivatedRouteSnapshot, state: RouterStateSnapshot) => MaybeAsync<GuardResult>;
+type MatchingGuard<Params, Search> = (inputs: Inputs<Params, Search>, routeConfig: Route$1, segments: UrlSegment[], partialSnapshot: PartialMatchRouteSnapshot) => MaybeAsync<GuardResult>;
+type RequiredKeys<Value> = {
+    [Key in keyof Value]-?: Pick<Value, Key> extends Required<Pick<Value, Key>> ? Key : never;
+}[keyof Value];
+type SearchInput<Schema, Keys extends keyof Schema> = keyof Schema extends never ? Record<string, never> : Pick<Schema, RequiredKeys<Schema> | Keys>;
+type UrlValues<Target extends AnyRoute, SearchKeys extends keyof SearchOf<Target> = keyof SearchOf<Target>> = (keyof ParamsOf<Target> extends never ? {
+    params?: never;
+} : {
+    params: ParamsOf<Target>;
+}) & (keyof SearchOf<Target> extends never ? {
+    search?: never;
+} : RequiredKeys<SearchOf<Target>> extends never ? {
+    search?: SearchInput<SearchOf<Target>, SearchKeys>;
+} : {
+    search: SearchInput<SearchOf<Target>, SearchKeys>;
+}) & (FragmentsOf<Target> extends never ? {
+    fragment?: never;
+} : {
+    fragment?: FragmentsOf<Target>;
+});
+type CompatibleKeys<Source, Value> = {
+    [Key in keyof Source]: Source[Key] extends Value ? Key : never;
+}[keyof Source];
+type Mapping<Source, Destination> = {
+    [Key in keyof Destination]: CompatibleKeys<Source, Destination[Key]>;
+};
+type Forwardable<Source, Destination> = {
+    [Key in keyof Destination]: Key extends keyof Source ? Source[Key] extends Destination[Key] ? never : Key : Key;
+}[keyof Destination] extends never ? true : false;
+type Preservable<Source, Destination> = {
+    [Key in RequiredKeys<Destination>]: Key extends RequiredKeys<Source> ? Source[Key & keyof Source] extends Destination[Key] ? never : Key : Key;
+}[RequiredKeys<Destination>] extends never ? true : false;
+type Redirect<SourceParams, SourceSearch, Target extends AnyRoute, SearchKeys extends keyof SearchOf<Target>> = {
+    to: Target;
+    search: {
+        mode: "replace";
+        values: SearchInput<SearchOf<NoInfer<Target>>, SearchKeys>;
+    } | (RequiredKeys<SearchOf<Target>> extends never ? {
+        mode: "drop";
+    } : never) | (Preservable<SourceSearch, SearchOf<Target>> extends true ? {
+        mode: "preserve";
+    } : never);
+    fragment: {
+        mode: "preserve" | "drop";
+    } | (FragmentsOf<Target> extends never ? never : {
+        mode: "replace";
+        value: FragmentsOf<Target>;
+    });
+} & (Forwardable<SourceParams, ParamsOf<Target>> extends true ? {
+    params?: Mapping<SourceParams, ParamsOf<Target>>;
+} : {
+    params: Mapping<SourceParams, ParamsOf<Target>>;
+});
+type RouteConfig<Path extends string, Parent extends AnyRoute | undefined, Params extends Record<string, PathCodec>, Search extends CodecMap, Resolvers, Fragments extends readonly string[], Target extends AnyRoute | undefined, ReplacementKeys extends keyof SearchOf<Target>> = {
+    parent?: Parent & (Parent extends Route<string, any, any, any, any, true> ? never : unknown);
+    search?: Search & Record<Extract<keyof Search, keyof SearchOf<Parent>>, never>;
+    resolve?: Resolvers & Record<PropertyKey, Resolver<EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>>> & {
+        __loozoAngularRouterRouteId?: never;
+    };
+    fragments?: Fragments;
+    runGuardsAndResolvers?: RunGuardsAndResolvers;
+    canActivateChild?: readonly ActivationGuard<EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>>[];
+    canDeactivate?: Route$1["canDeactivate"];
+    providers?: Route$1["providers"];
+    title?: Route$1["title"];
+    data?: Route$1["data"] & {
+        __loozoAngularRouterRouteId?: never;
+    };
+} & (PathNames<Path> extends never ? {
+    params?: never;
+} : {
+    params: Params & Record<PathNames<Path>, PathCodec> & Record<Exclude<keyof Params, PathNames<Path>> | Extract<keyof Params, keyof ParamsOf<Parent>>, never>;
+}) & (Target extends AnyRoute ? {
+    redirect: Redirect<EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>, Target, ReplacementKeys>;
+    canActivate?: never;
+    canMatch?: never;
+} : {
+    redirect?: never;
+    canActivate?: readonly ActivationGuard<EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>>[];
+    canMatch?: readonly MatchingGuard<LocalParams<Path, Params>, EffectiveSearch<Search, Parent>>[];
+});
+
+interface RouteMetadata {
+    readonly parent?: AnyRoute;
+    readonly localSegments: readonly Segment[];
+    readonly segments: readonly Segment[];
+    readonly localParams: Readonly<Record<string, ParamCodec<any>>>;
+    readonly localSearch: Readonly<Record<string, ParamCodec<any>>>;
+    readonly params: Readonly<Record<string, ParamCodec<any>>>;
+    readonly search: Readonly<Record<string, ParamCodec<any>>>;
+    readonly fragments: readonly string[];
+    readonly config: Readonly<Record<string, unknown>>;
+}
+declare function routeMetadata(route: unknown): RouteMetadata;
+declare function defineRoute<const Path extends string, Parent extends AnyRoute | undefined = undefined, Params extends Record<string, PathCodec> = {}, Search extends CodecMap = {}, Resolvers extends Record<string, (...args: any[]) => unknown> = {}, const Fragments extends readonly string[] = [], Target extends AnyRoute | undefined = undefined, ReplacementKeys extends keyof SearchOf<NoInfer<Target>> = never>(path: Path & ValidPath<Path>, config: RouteConfig<Path, Parent, Params, Search, Resolvers, Fragments, Target, ReplacementKeys>): Route<Path, EffectiveParams<Path, Params, Parent>, EffectiveSearch<Search, Parent>, Resolvers, Fragments[number], CatchallName<Path> extends never ? false : true>;
+
+declare function createUrl<Target extends AnyRoute, SearchKeys extends keyof SearchOf<NoInfer<Target>> = never>(route: Target, values: UrlValues<NoInfer<Target>, SearchKeys>): string;
+
+export { booleanParam, codecPresence, createUrl, defineRoute, enumParam, nullableSearchParam, numberParam, optionalSearchParam, routeMetadata, stringParam };
+export type { AnyRoute, FragmentsOf, Inputs, ParamCodec, ParamsOf, Route, RouteMetadata, SearchOf, UrlValues };

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

@@ -0,0 +1,56 @@
+import { ActivatedRouteSnapshot, Route, RedirectFunction, UrlTree } from '@angular/router';
+import { AnyRoute, ParamsOf, SearchOf, UrlValues } from '@loozo/angular-router/_core';
+import { Resource } from '@angular/core';
+
+interface RecordBinding {
+    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>>>>;
+}
+interface Parsed {
+    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;
+
+declare const destinationBrand: unique symbol;
+declare class Destination<Target extends AnyRoute, Set = unknown, Id extends string = string> {
+    #private;
+    readonly [destinationBrand]: {
+        readonly target: Target;
+        readonly set: Set;
+        readonly id: Id;
+    };
+}
+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> : never;
+type IsUnion<Value, Whole = Value> = Value extends unknown ? [Whole] extends [Value] ? false : true : never;
+interface Handle<Target extends AnyRoute, Selected extends Record<string, AnyRoute> = {}, Set = unknown, References extends Record<string, AnyRoute> = {}> {
+    readonly params: Resource<Readonly<ParamsOf<Target>> | undefined>;
+    readonly search: Resource<Readonly<SearchOf<Target>> | undefined>;
+    readonly data: Resource<DataOf<Target> | undefined>;
+    link<Keys extends keyof SearchOf<Target> = never>(values: UrlValues<Target, Keys>): UrlTree;
+    link<Keys extends keyof SearchOf<Target> = never>(selector: ".", values: UrlValues<Target, Keys>): UrlTree;
+    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;
+    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;
+    navigate<Keys extends keyof SearchOf<Target> = never>(values: UrlValues<Target, Keys>): Promise<boolean>;
+    navigate<Keys extends keyof SearchOf<Target> = never>(selector: ".", values: UrlValues<Target, Keys>): Promise<boolean>;
+    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>;
+    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 };

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

@@ -0,0 +1 @@
+export { ParamCodec, Route, booleanParam, createUrl, defineRoute, enumParam, nullableSearchParam, numberParam, optionalSearchParam, stringParam } from '@loozo/angular-router/_core';