@kitbag/router 0.22.1 → 0.22.3

package/dist/main.d.ts

@@ -144,6 +144,13 @@ export declare const useQueryValue: RouterAssets<RegisteredRouter>['useQueryValu
  * @group Compositions
  */
 export declare const useLink: RouterAssets<RegisteredRouter>['useLink'];
+/**
+ * A composition to access the rejection from the router.
+ *
+ * @returns The rejection from the router.
+ * @group Compositions
+ */
+export declare const useRejection: RouterAssets<RegisteredRouter>['useRejection'];
 declare module 'vue' {
     interface GlobalComponents {
         RouterView: typeof RouterView;

package/dist/services/combineHash.d.ts

@@ -1,4 +1,5 @@
-import { WithParams } from './withParams';
+import { UrlPart } from './withParams';
 import { CombinePath } from './combinePath';
-export type CombineHash<TParent extends WithParams, TChild extends WithParams> = CombinePath<TParent, TChild>;
-export declare function combineHash<TParentHash extends WithParams, TChildHash extends WithParams>(parentHash: TParentHash, childHash: TChildHash): CombineHash<TParentHash, TChildHash>;
+type CombineHash<TParent extends UrlPart, TChild extends UrlPart> = CombinePath<TParent, TChild>;
+export declare function combineHash<TParentHash extends UrlPart, TChildHash extends UrlPart>(parentHash: TParentHash, childHash: TChildHash): CombineHash<TParentHash, TChildHash>;
+export {};

package/dist/services/combinePath.d.ts

@@ -1,12 +1,8 @@
-import { ToWithParams, WithParams } from './withParams';
-import { Param } from '../types/paramTypes';
-type CombinePathString<TParent extends string, TChild extends string> = `${TParent}${TChild}`;
-export type CombinePath<TParent extends WithParams, TChild extends WithParams> = ToWithParams<TParent> extends {
-    value: infer TParentPath extends string;
-    params: infer TParentParams extends Record<string, unknown>;
-} ? ToWithParams<TChild> extends {
-    value: infer TChildPath extends string;
-    params: infer TChildParams extends Record<string, unknown>;
-} ? TParentParams & TChildParams extends Record<string, Param | undefined> ? WithParams<CombinePathString<TParentPath, TChildPath>, TParentParams & TChildParams> : WithParams<CombinePathString<TParentPath, TChildPath>, {}> : WithParams<'', {}> : WithParams<'', {}>;
-export declare function combinePath<TParentPath extends WithParams, TChildPath extends WithParams>(parentPath: TParentPath, childPath: TChildPath): CombinePath<TParentPath, TChildPath>;
-export {};
+import { ToUrlPart, UrlPart, UrlParams } from './withParams';
+import { Identity } from '../types/utilities';
+export type CombinePath<TParent extends UrlPart, TChild extends UrlPart> = ToUrlPart<TParent> extends {
+    params: infer TParentParams extends UrlParams;
+} ? ToUrlPart<TChild> extends {
+    params: infer TChildParams extends UrlParams;
+} ? TParentParams & TChildParams extends UrlParams ? UrlPart<Identity<TParentParams & TChildParams>> : UrlPart<{}> : UrlPart<{}> : UrlPart<{}>;
+export declare function combinePath<TParentPath extends UrlPart, TChildPath extends UrlPart>(parentPath: TParentPath, childPath: TChildPath): CombinePath<TParentPath, TChildPath>;

package/dist/services/combineQuery.d.ts

@@ -1,13 +1,9 @@
-import { StringHasValue } from '../utilities/guards';
-import { ToWithParams, WithParams } from './withParams';
-import { Param } from '../types/paramTypes';
-type CombineQueryString<TParent extends string | undefined, TChild extends string | undefined> = StringHasValue<TParent> extends true ? StringHasValue<TChild> extends true ? `${TParent}&${TChild}` : TParent : TChild;
-export type CombineQuery<TParent extends WithParams, TChild extends WithParams> = ToWithParams<TParent> extends {
-    value: infer TParentQuery extends string;
-    params: infer TParentParams extends Record<string, unknown>;
-} ? ToWithParams<TChild> extends {
-    value: infer TChildQuery extends string;
-    params: infer TChildParams extends Record<string, unknown>;
-} ? TParentParams & TChildParams extends Record<string, Param | undefined> ? WithParams<CombineQueryString<TParentQuery, TChildQuery>, TParentParams & TChildParams> : WithParams<CombineQueryString<TParentQuery, TChildQuery>, {}> : WithParams<'', {}> : WithParams<'', {}>;
-export declare function combineQuery<TParentQuery extends WithParams, TChildQuery extends WithParams>(parentQuery: TParentQuery, childQuery: TChildQuery): CombineQuery<TParentQuery, TChildQuery>;
+import { ToUrlPart, UrlPart, UrlParams } from './withParams';
+import { Identity } from '../types/utilities';
+type CombineQuery<TParent extends UrlPart, TChild extends UrlPart> = ToUrlPart<TParent> extends {
+    params: infer TParentParams extends UrlParams;
+} ? ToUrlPart<TChild> extends {
+    params: infer TChildParams extends UrlParams;
+} ? TParentParams & TChildParams extends UrlParams ? UrlPart<Identity<TParentParams & TChildParams>> : UrlPart<{}> : UrlPart<{}> : UrlPart<{}>;
+export declare function combineQuery<TParentQuery extends UrlPart, TChildQuery extends UrlPart>(parentQuery: TParentQuery, childQuery: TChildQuery): CombineQuery<TParentQuery, TChildQuery>;
 export {};

package/dist/services/combineUrl.d.ts

@@ -1,4 +1,5 @@
 import { CreateUrlOptions, ToUrl, Url } from '../types/url';
-export type CombineUrl<TParent extends Url, TChild extends Url> = TParent extends Url<infer TParentParams> ? TChild extends Url<infer TChildParams> ? Url<TParentParams & TChildParams> : never : never;
+import { Identity } from '../types/utilities';
+export type CombineUrl<TParent extends Url, TChild extends Url> = TParent extends Url<infer TParentParams> ? TChild extends Url<infer TChildParams> ? Url<Identity<TParentParams & TChildParams>> : never : never;
 export declare function combineUrl<const TParent extends Url, const TChild extends Url>(parent: TParent, child: TChild): CombineUrl<TParent, TChild>;
 export declare function combineUrl<const TParent extends Url, const TChild extends CreateUrlOptions>(parent: TParent, child: TChild): CombineUrl<TParent, ToUrl<TChild>>;

package/dist/services/createRouteHooks.d.ts

@@ -3,7 +3,7 @@ import { Routes } from '../types/route';
 import { Hooks } from '../models/hooks';
 import { Rejection } from '../types/rejection';
 import { RouteRedirect } from '../types/redirects';
-export type RouteHooks<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = {
+type RouteHooks<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = {
     redirect: RouteRedirect;
     onBeforeRouteEnter: AddBeforeEnterHook<TRoutes, TRejections>;
     onBeforeRouteUpdate: AddBeforeUpdateHook<TRoutes, TRejections>;
@@ -15,3 +15,4 @@ export type RouteHooks<TRoutes extends Routes = Routes, TRejections extends Reje
     store: Hooks;
 };
 export declare function createRouteHooks(): RouteHooks;
+export {};

package/dist/services/createRouterAssets.d.ts

@@ -8,6 +8,7 @@ import { createUseQueryValue } from '../compositions/useQueryValue';
 import { createUseLink } from '../compositions/useLink';
 import { createIsRoute } from '../guards/routes';
 import { AddBeforeLeaveHook, AddBeforeUpdateHook, AddAfterLeaveHook, AddAfterUpdateHook } from '../types/hooks';
+import { createUseRejection } from '../compositions/useRejection';
 export type RouterAssets<TRouter extends Router> = {
     /**
      * Registers a hook that is called before a route is left. Must be called from setup.
@@ -113,6 +114,13 @@ export type RouterAssets<TRouter extends Router> = {
      * @group Compositions
      */
     useLink: ReturnType<typeof createUseLink<TRouter>>;
+    /**
+     * A composition to access the rejection from the router.
+     *
+     * @returns The rejection from the router.
+     * @group Compositions
+     */
+    useRejection: ReturnType<typeof createUseRejection<TRouter>>;
 };
 export declare function createRouterAssets<TRouter extends Router>(router: TRouter): RouterAssets<TRouter>;
 export declare function createRouterAssets<TRouter extends Router>(routerKey: InjectionKey<TRouter>): RouterAssets<TRouter>;

package/dist/services/createRouterCallbackContext.d.ts

@@ -1,43 +1,15 @@
 import { RouterPush } from '../types/routerPush';
 import { RouterReject } from '../types/routerReject';
 import { RouterReplace } from '../types/routerReplace';
-import { BuiltInRejectionType } from './createRouterReject';
-import { AsString } from '../types/utilities';
 import { Routes } from '../types/route';
 import { Rejections } from '../types/rejection';
 import { RouteUpdate } from '../types/routeUpdate';
 import { ResolvedRoute } from '../types/resolved';
-/**
- * Defines the structure of a successful callback response.
- */
-export type RouterCallbackSuccessResponse = {
-    status: 'SUCCESS';
-};
-/**
- * Defines the structure of an aborted callback response.
- */
-export type RouterCallbackAbortResponse = {
-    status: 'ABORT';
-};
-/**
- * Defines the structure of a callback response that results in a push to a new route.
- */
-export type RouterCallbackPushResponse<TRoutes extends Routes> = {
-    status: 'PUSH';
-    to: Parameters<RouterPush<TRoutes>>;
-};
-/**
- * Defines the structure of a callback response that results in the rejection of a route transition.
- */
-export type RouterCallbackRejectResponse<TRejections extends string> = {
-    status: 'REJECT';
-    type: AsString<TRejections> | BuiltInRejectionType;
-};
 /**
  * A function that can be called to abort a routing operation.
  */
 export type CallbackContextAbort = () => void;
-export type RouterCallbackContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
+type RouterCallbackContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;
@@ -47,3 +19,4 @@ export type RouterCallbackContext<TRoutes extends Routes = Routes, TRejections e
 export declare function createRouterCallbackContext<TRoutes extends Routes, TRejections extends Rejections>({ to }: {
     to: ResolvedRoute;
 }): RouterCallbackContext<TRoutes, TRejections>;
+export {};

package/dist/services/createRouterHistory.d.ts

@@ -5,7 +5,7 @@ type NavigationPushOptions = {
 };
 type NavigationUpdate = (url: string, options?: NavigationPushOptions) => void;
 type NavigationRefresh = () => void;
-export type RouterHistory = History & {
+type RouterHistory = History & {
     update: NavigationUpdate;
     refresh: NavigationRefresh;
     startListening: () => void;

package/dist/services/createRouterReject.d.ts

@@ -1,11 +1,14 @@
 import { Ref } from 'vue';
 import { ResolvedRoute } from '../types/resolved';
 import { Rejection } from '../types/rejection';
+import { Router } from '../types/router';
+import { RouterReject } from '../types/routerReject';
 export type BuiltInRejectionType = 'NotFound';
-export type RouterSetReject = (type: string | null) => void;
+type RouterSetReject = (type: string | null) => void;
 type GetRejectionRoute = (type: string) => ResolvedRoute;
-export type RouterRejection = Ref<Rejection | null>;
-export type CreateRouterReject = {
+export type RouterRejection<T extends Rejection = Rejection> = Ref<T | null>;
+export type RouterRejections<TRouter extends Router> = TRouter['reject'] extends RouterReject<infer TRejections extends Rejection[]> ? TRejections[number] : never;
+type CreateRouterReject = {
     setRejection: RouterSetReject;
     rejection: RouterRejection;
     getRejectionRoute: GetRejectionRoute;

package/dist/services/createVueAppStore.d.ts

@@ -2,7 +2,8 @@ import { App } from 'vue';
 export type HasVueAppStore = {
     setVueApp: (app: App) => void;
 };
-export type VueAppStore = HasVueAppStore & {
+type VueAppStore = HasVueAppStore & {
     runWithContext: <T>(callback: () => T) => T;
 };
 export declare function createVueAppStore(): VueAppStore;
+export {};

package/dist/services/getParamsForString.d.ts

@@ -1,2 +1,3 @@
+import { UrlParams } from './withParams';
 import { Param } from '../types/paramTypes';
-export declare function getParamsForString(string?: string, params?: Record<string, Param | undefined>): Record<string, Param>;
+export declare function getParamsForString(string?: string, params?: Record<string, Param | undefined>): UrlParams;

package/dist/services/params.d.ts

@@ -1,7 +1,8 @@
+import { UrlParam } from './withParams';
 import { ExtractParamType } from '../types/params';
 import { Param } from '../types/paramTypes';
 export declare function getParam(params: Record<string, Param | undefined>, paramName: string): Param;
-export declare function getParamValue<T extends Param>(value: string | undefined, param: T, isOptional?: boolean): ExtractParamType<T>;
-export declare function safeGetParamValue<T extends Param>(value: string | undefined, param: T, isOptional?: boolean): ExtractParamType<T> | undefined;
-export declare function safeSetParamValue(value: unknown, param: Param, isOptional?: boolean): string | undefined;
-export declare function setParamValue(value: unknown, param: Param, isOptional?: boolean): string;
+export declare function getParamValue<T extends Param>(value: string | undefined, param: Partial<UrlParam<T>>): ExtractParamType<T>;
+export declare function safeGetParamValue<T extends Param>(value: string | undefined, param: Partial<UrlParam<T>>): ExtractParamType<T> | undefined;
+export declare function safeSetParamValue(value: unknown, param: Partial<UrlParam>): string | undefined;
+export declare function setParamValue(value: unknown, { param, isOptional }?: Partial<UrlParam>): string;

package/dist/services/paramsFinder.d.ts

@@ -1,3 +1,3 @@
-import { WithParams } from './withParams';
-export declare function getParamValueFromUrl(url: string, path: WithParams, paramName: string): string | undefined;
-export declare function setParamValueOnUrl(url: string, path: WithParams, paramName: string, value: unknown): string;
+import { UrlPart } from './withParams';
+export declare function getParamValueFromUrl(url: string, path: UrlPart, paramName: string): string | undefined;
+export declare function setParamValueOnUrl(url: string, path: UrlPart, paramName: string, value: unknown): string;

package/dist/services/routeRegex.d.ts

@@ -1,3 +1,4 @@
+import { UrlPart } from './withParams';
 export declare const paramRegex = "\\[\\??([\\w-_]+)\\*?\\]";
 export declare const optionalParamRegex = "\\[\\?([\\w-_]+)\\*?\\]";
 export declare const requiredParamRegex = "\\[([\\w-_]+)\\*?\\]";
@@ -6,17 +7,13 @@ export declare const regexCatchAll = "[^/]*";
 export declare const regexGreedyCatchAll = ".*";
 export declare const regexCaptureAll = "([^/]*)";
 export declare const regexGreedyCaptureAll = "(.*)";
-export declare function escapeRegExp(string: string): string;
 export declare function splitByMatches(string: string, regexp: RegExp): string[];
 export declare function generateRouteHostRegexPattern(host: string): RegExp;
 export declare function generateRoutePathRegexPattern(path: string): RegExp;
 export declare function generateRouteHashRegexPattern(hash: string): RegExp;
 export declare function generateRouteQueryRegexPatterns(query: string): RegExp[];
-export declare function replaceParamSyntaxWithCatchAllsAndEscapeRest(value: string): string;
 export declare function replaceParamSyntaxWithCatchAlls(value: string): string;
-export declare function replaceIndividualParamWithCaptureGroup(path: string, paramName: string): string;
-export declare function paramIsOptional(path: string, paramName: string): boolean;
-export declare function paramIsGreedy(path: string, paramName: string): boolean;
+export declare function replaceIndividualParamWithCaptureGroup(path: UrlPart, paramName: string): string;
 export declare function isOptionalParamSyntax(value: string): boolean;
 export declare function isRequiredParamSyntax(value: string): boolean;
 export declare function isGreedyParamSyntax(value: string): boolean;

package/dist/services/urlParser.d.ts

@@ -1,12 +1,12 @@
 import { QuerySource } from '../types/querySource';
 import { UrlString } from '../types/urlString';
-export type UrlParts = {
+type UrlParts = {
     host?: string;
     path: string;
     query: URLSearchParams;
     hash: string;
 };
-export type UrlPartsInput = {
+type UrlPartsInput = {
     host?: string;
     path?: string;
     query?: QuerySource;
@@ -16,3 +16,4 @@ export declare function stringifyUrl(parts: UrlPartsInput): UrlString;
 export declare function parseUrl(value: string): UrlParts;
 export declare function updateUrl(url: string, updates: UrlPartsInput): UrlString;
 export declare function updateUrl(url: Partial<UrlParts>, updates: UrlPartsInput): UrlParts;
+export {};

package/dist/services/withParams.d.ts

@@ -1,15 +1,70 @@
-import { ExtractParamName, ParamEnd, ParamStart } from '../types/params';
+import { ExtractParamName, ParamEnd, ParamIsGreedy, ParamIsOptional, ParamStart } from '../types/params';
 import { Param } from '../types/paramTypes';
 import { Identity } from '../types/utilities';
 import { MakeOptional } from '../utilities/makeOptional';
 type WithParamsParamsInput<TValue extends string> = TValue extends `${string}${ParamStart}${infer TParam}${ParamEnd}${infer Rest}` ? Record<ExtractParamName<TParam>, Param | undefined> & WithParamsParamsInput<Rest> : {};
-type WithParamsParamsOutput<TValue extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TValue extends `${string}${ParamStart}${infer TParam}${ParamEnd}${infer Rest}` ? ExtractParamName<TParam> extends keyof TParams ? Record<ExtractParamName<TParam>, TParams[ExtractParamName<TParam>]> & WithParamsParamsOutput<Rest, TParams> : Record<ExtractParamName<TParam>, StringConstructor> & WithParamsParamsOutput<Rest, TParams> : {};
-export type WithParams<TValue extends string = string, TParams extends Record<string, Param | undefined> = Record<string, Param | undefined>> = {
-    value: TValue;
-    params: string extends TValue ? Record<string, Param> : Identity<WithParamsParamsOutput<TValue, TParams>>;
-};
-export type ToWithParams<T extends string | WithParams | undefined> = T extends string ? WithParams<T, {}> : T extends undefined ? WithParams<'', {}> : unknown extends T ? WithParams<'', {}> : T;
-export declare function toWithParams<T extends string | WithParams | undefined>(value: T): ToWithParams<T>;
-export declare function withParams<const TValue extends string, const TParams extends MakeOptional<WithParamsParamsInput<TValue>>>(value: TValue, params: TParams): WithParams<TValue, TParams>;
-export declare function withParams(): WithParams<'', {}>;
+type WithParamsParamsOutput<TValue extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TValue extends `${string}${ParamStart}${infer TParam}${ParamEnd}${infer Rest}` ? ExtractParamName<TParam> extends keyof TParams ? TParams[ExtractParamName<TParam>] extends Param ? Record<ExtractParamName<TParam>, {
+    param: TParams[ExtractParamName<TParam>];
+    isOptional: ParamIsOptional<TParam>;
+    isGreedy: ParamIsGreedy<TParam>;
+}> & WithParamsParamsOutput<Rest, TParams> : Record<ExtractParamName<TParam>, {
+    param: StringConstructor;
+    isOptional: ParamIsOptional<TParam>;
+    isGreedy: ParamIsGreedy<TParam>;
+}> & WithParamsParamsOutput<Rest, TParams> : Record<ExtractParamName<TParam>, {
+    param: StringConstructor;
+    isOptional: ParamIsOptional<TParam>;
+    isGreedy: ParamIsGreedy<TParam>;
+}> & WithParamsParamsOutput<Rest, TParams> : {};
+declare const UrlPartsWithParamsSymbol: unique symbol;
+export type UrlParam<TParam extends Param = Param> = {
+    param: TParam;
+    isOptional: boolean;
+    isGreedy: boolean;
+};
+export type RequiredUrlParam<TParam extends Param = Param> = {
+    param: TParam;
+    isOptional: false;
+    isGreedy: false;
+};
+export type OptionalUrlParam<TParam extends Param = Param> = {
+    param: TParam;
+    isOptional: true;
+    isGreedy: false;
+};
+export type UrlParams = Record<string, UrlParam>;
+export type UrlPart<TParams extends UrlParams = UrlParams> = {
+    value: string;
+    params: TParams;
+    [UrlPartsWithParamsSymbol]: true;
+};
+export type ToUrlPart<T extends string | UrlPart | undefined> = T extends string ? UrlPart<WithParamsParamsOutput<T>> : T extends undefined ? UrlPart<{}> : unknown extends T ? UrlPart<{}> : T;
+export declare function toUrlPart<T extends string | UrlPart | undefined>(value: T): ToUrlPart<T>;
+export declare function withParams<const TValue extends string, const TParams extends MakeOptional<WithParamsParamsInput<TValue>>>(value: TValue, params: TParams): UrlPart<WithParamsParamsOutput<TValue, TParams>>;
+export declare function withParams(): UrlPart<{}>;
+/**
+ * Type for query source that can be converted to a UrlPart object.
+ * Supports
+ * { query: 'foo=bar' }
+ * { query: 'foo=[bar]' }
+ * { query: { foo: 'bar' } }
+ * { query: [['foo', 'bar']] }
+ * { query: { foo: Param } }
+ * { query: [[ 'foo', Param ]] }
+*/
+export type UrlQueryPart = UrlPart | Record<string, Param> | [string, Param][];
+export type ToUrlQueryPart<T extends UrlQueryPart | string | undefined> = T extends string ? UrlPart<WithParamsParamsOutput<T>> : T extends UrlPart ? T : T extends undefined ? UrlPart<{}> : T extends Record<string, string | Param> ? UrlPart<QueryRecordToUrlPart<T>> : T extends [string, string | Param][] ? UrlPart<QueryArrayToUrlPart<T>> : UrlPart<{}>;
+type QueryRecordToUrlPart<T extends Record<string, Param>> = {
+    [K in keyof T as T[K] extends string ? never : ExtractParamName<K & string>]: {
+        param: T[K];
+        isOptional: ParamIsOptional<K & string>;
+        isGreedy: false;
+    };
+};
+type QueryArrayToUrlPart<T extends [string, string | Param][]> = T extends [infer First extends [string, string | Param], ...infer Rest extends [string, string | Param][]] ? First extends [string, string] ? {} : First extends [infer TKey extends string, infer TValue extends Param] ? Identity<Record<ExtractParamName<TKey>, {
+    param: TValue;
+    isOptional: ParamIsOptional<TKey>;
+    isGreedy: false;
+}> & QueryArrayToUrlPart<Rest>> : never : {};
+export declare function toUrlQueryPart<T extends UrlQueryPart | string | undefined>(querySource: T): ToUrlQueryPart<T>;
 export {};

package/dist/types/createRouteOptions.d.ts

@@ -12,12 +12,12 @@ import { MaybePromise } from './utilities';
 import { ToMeta } from './meta';
 import { ToState } from './state';
 import { ToName } from './name';
-import { WithParams } from '../services/withParams';
+import { UrlPart, UrlQueryPart } from '../services/withParams';
 import { RouteContext, ToRouteContext } from './routeContext';
 import { RouterViewProps } from '../components/routerView';
 import { ToUrl } from './url';
 import { CombineUrl } from '../services/combineUrl';
-export type WithHost<THost extends string | WithParams = string | WithParams> = {
+export type WithHost<THost extends string | UrlPart = string | UrlPart> = {
     /**
      * Host part of URL.
      */
@@ -53,15 +53,15 @@ export type CreateRouteOptions<TName extends string | undefined = string | undef
     /**
      * Path part of URL.
      */
-    path?: string | WithParams | undefined;
+    path?: string | UrlPart | undefined;
     /**
      * Query (aka search) part of URL.
      */
-    query?: string | WithParams | undefined;
+    query?: string | UrlQueryPart | undefined;
     /**
      * Hash part of URL.
      */
-    hash?: string | WithParams | undefined;
+    hash?: string | UrlPart | undefined;
     /**
      * Represents additional metadata associated with a route, customizable via declaration merging.
      */

package/dist/types/params.d.ts

@@ -22,13 +22,6 @@ export declare function isParamGetSet(value: Param): value is ParamGetSet;
  * @returns True if the value is a string, number, or boolean.
  */
 export declare function isLiteralParam(value: Param): value is LiteralParam;
-/**
- * Determines if a given value is an optional parameter template.
- * @template TKey - The key of the parameter.
- * @template TValue - The value of the parameter.
- * @returns True if the value is an optional parameter template.
- */
-export type IsOptionalParamTemplate<TKey extends string, TValue extends string> = TValue extends `${string}${ParamStart}?${TKey}${ParamEnd}${string}` ? true : TValue extends `${string}${ParamStart}?${TKey}*${ParamEnd}${string}` ? true : false;
 /**
  * Extracts the parameter name from a string, handling optional parameters denoted by a leading '?'.
  * @template TParam - The string from which to extract the parameter name.
@@ -41,3 +34,5 @@ export type ExtractParamName<TParam extends PropertyKey> = TParam extends string
  * @returns The extracted type, or 'string' as a fallback.
  */
 export type ExtractParamType<TParam extends Param> = Param extends TParam ? unknown : TParam extends ParamGetSet<infer Type> ? Type : TParam extends ParamGetter ? ReturnType<TParam> : TParam extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TParam> : TParam extends LiteralParam ? TParam : string;
+export type ParamIsOptional<TParam extends string> = TParam extends `?${string}` ? true : false;
+export type ParamIsGreedy<TParam extends string> = TParam extends `${string}*` ? true : false;

package/dist/types/routeContext.d.ts

@@ -1,11 +1,15 @@
 import { CreateRouteOptions } from './createRouteOptions';
 import { Rejection, Rejections } from './rejection';
-import { GenericRoute, Routes } from './route';
+import { GenericRoute, Route, Routes } from './route';
 export type RouteContext = GenericRoute | Rejection;
 export type ToRouteContext<TContext extends RouteContext[] | readonly RouteContext[] | undefined> = TContext extends RouteContext[] ? TContext : [];
 export type ExtractRouteContext<TOptions extends CreateRouteOptions> = TOptions extends {
     context: infer TContext extends RouteContext[];
-} ? TContext : [];
+} ? TOptions extends {
+    parent: infer TParent extends Route;
+} ? [...ToRouteContext<TParent['context']>, ...TContext] : TContext : TOptions extends {
+    parent: infer TParent extends Route;
+} ? ToRouteContext<TParent['context']> : [];
 export type ExtractRouteContextRoutes<TOptions extends CreateRouteOptions> = RouteContextToRoute<ExtractRouteContext<TOptions>>;
 export type ExtractRouteContextRejections<TOptions extends CreateRouteOptions> = RouteContextToRejection<ExtractRouteContext<TOptions>>;
 export type RouteContextToRoute<TContext extends RouteContext[] | undefined> = RouteContext[] extends TContext ? Routes : undefined extends TContext ? Routes : FilterRouteContextRoutes<TContext>;

package/dist/types/router.d.ts

@@ -11,7 +11,6 @@ import { RouterResolve, RouterResolveOptions } from './routerResolve';
 import { RouterReject } from './routerReject';
 import { RouterPlugin } from './routerPlugin';
 import { RoutesName } from './routesMap';
-import { ToRouteContext } from './routeContext';
 import { ExtractRejections, Rejections } from './rejection';
 /**
  * Options to initialize a {@link Router} instance.
@@ -105,32 +104,32 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
     /**
      * Registers a hook to be called before a route is entered.
      */
-    onBeforeRouteEnter: AddBeforeEnterHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
+    onBeforeRouteEnter: AddBeforeEnterHook<TRoutes | TPlugin['routes'], ExtractRejections<TOptions> | ExtractRejections<TPlugin>>;
     /**
      * Registers a hook to be called before a route is left.
      */
-    onBeforeRouteLeave: AddBeforeLeaveHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
+    onBeforeRouteLeave: AddBeforeLeaveHook<TRoutes | TPlugin['routes'], ExtractRejections<TOptions> | ExtractRejections<TPlugin>>;
     /**
      * Registers a hook to be called before a route is updated.
      */
-    onBeforeRouteUpdate: AddBeforeUpdateHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
+    onBeforeRouteUpdate: AddBeforeUpdateHook<TRoutes | TPlugin['routes'], ExtractRejections<TOptions> | ExtractRejections<TPlugin>>;
     /**
      * Registers a hook to be called after a route is entered.
      */
-    onAfterRouteEnter: AddAfterEnterHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
+    onAfterRouteEnter: AddAfterEnterHook<TRoutes | TPlugin['routes'], ExtractRejections<TOptions> | ExtractRejections<TPlugin>>;
     /**
      * Registers a hook to be called after a route is left.
      */
-    onAfterRouteLeave: AddAfterLeaveHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
+    onAfterRouteLeave: AddAfterLeaveHook<TRoutes | TPlugin['routes'], ExtractRejections<TOptions> | ExtractRejections<TPlugin>>;
     /**
      * Registers a hook to be called after a route is updated.
      */
-    onAfterRouteUpdate: AddAfterUpdateHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
+    onAfterRouteUpdate: AddAfterUpdateHook<TRoutes | TPlugin['routes'], ExtractRejections<TOptions> | ExtractRejections<TPlugin>>;
     /**
      * Registers a hook to be called when an error occurs.
      * If the hook returns true, the error is considered handled and the other hooks are not run. If all hooks return false the error is rethrown
      */
-    onError: AddErrorHook<TRoutes[number] | TPlugin['routes'][number], TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
+    onError: AddErrorHook<TRoutes[number] | TPlugin['routes'][number], TRoutes | TPlugin['routes'], ExtractRejections<TOptions> | ExtractRejections<TPlugin>>;
     /**
     * Given a URL, returns true if host does not match host stored on router instance
     */

package/dist/types/url.d.ts

@@ -1,29 +1,23 @@
-import { ToWithParams, WithParams } from '../services/withParams';
-import { ExtractParamType, IsOptionalParamTemplate } from './params';
+import { OptionalUrlParam, UrlQueryPart, ToUrlQueryPart, RequiredUrlParam, ToUrlPart, UrlParams, UrlPart } from '../services/withParams';
+import { ExtractParamType } from './params';
 import { AllPropertiesAreOptional, Identity } from './utilities';
 import { UrlString } from './urlString';
-import { Param, ParamGetSet } from './paramTypes';
+import { ParamGetSet } from './paramTypes';
 import { MakeOptional } from '../utilities/makeOptional';
 export declare const IS_URL_SYMBOL: unique symbol;
 export type CreateUrlOptions = {
-    host?: string | WithParams | undefined;
-    path?: string | WithParams | undefined;
-    query?: string | WithParams | undefined;
-    hash?: string | WithParams | undefined;
-};
-export type ToUrl<TOptions extends CreateUrlOptions> = Url<ToUrlParams<ToWithParams<TOptions['host']>> & ToUrlParams<ToWithParams<TOptions['path']>> & ToUrlParams<ToWithParams<TOptions['query']>> & ToUrlParams<ToWithParams<TOptions['hash']>>>;
-type OptionalParam<TParam extends Param = Param> = [param: TParam, isOptional: true];
-type RequiredParam<TParam extends Param = Param> = [param: TParam, isOptional: false];
-type UrlParams = Record<string, OptionalParam | RequiredParam>;
-type ToUrlParams<TWithParams extends WithParams> = {
-    [K in keyof TWithParams['params']]: [TWithParams['params'][K], IsOptionalParamTemplate<K & string, TWithParams['value']>];
+    host?: string | UrlPart | undefined;
+    path?: string | UrlPart | undefined;
+    query?: string | UrlQueryPart | undefined;
+    hash?: string | UrlPart | undefined;
 };
+export type ToUrl<TOptions extends CreateUrlOptions> = Url<Identity<ToUrlPart<TOptions['host']>['params'] & ToUrlPart<TOptions['path']>['params'] & ToUrlQueryPart<TOptions['query']>['params'] & ToUrlPart<TOptions['hash']>['params']>>;
 /**
  * Type guard to assert that a url has a schema.
  * @internal
  */
 export declare function isUrlWithSchema(url: unknown): url is Url & {
-    schema: Record<string, WithParams>;
+    schema: Record<string, UrlPart>;
 };
 /**
  * Represents the structure of a url parts. Can be used to create a url with support for params.
@@ -71,7 +65,7 @@ type UrlParamsArgs<TParams extends UrlParams> = AllPropertiesAreOptional<ToUrlPa
 */
 export type UrlParamsReading<TUrl extends Url> = ToUrlParamsReading<TUrl['params']>;
 type ToUrlParamsReading<TParams extends UrlParams> = Identity<MakeOptional<{
-    [K in keyof TParams]: TParams[K] extends OptionalParam<infer TParam> ? TParam extends Required<ParamGetSet> ? ExtractParamType<TParam> : ExtractParamType<TParam> | undefined : TParams[K] extends RequiredParam<infer TParam> ? ExtractParamType<TParam> : unknown;
+    [K in keyof TParams]: TParams[K] extends OptionalUrlParam<infer TParam> ? TParam extends Required<ParamGetSet> ? ExtractParamType<TParam> : ExtractParamType<TParam> | undefined : TParams[K] extends RequiredUrlParam<infer TParam> ? ExtractParamType<TParam> : unknown;
 }>>;
 /**
 * Extracts combined types of path and query parameters for a given url, creating a unified parameter object.
@@ -81,6 +75,6 @@ type ToUrlParamsReading<TParams extends UrlParams> = Identity<MakeOptional<{
 */
 export type UrlParamsWriting<TUrl extends Url> = ToUrlParamsWriting<TUrl['params']>;
 type ToUrlParamsWriting<TParams extends UrlParams> = Identity<MakeOptional<{
-    [K in keyof TParams]: TParams[K] extends OptionalParam<infer TParam> ? ExtractParamType<TParam> | undefined : TParams[K] extends RequiredParam<infer TParam> ? ExtractParamType<TParam> : unknown;
+    [K in keyof TParams]: TParams[K] extends OptionalUrlParam<infer TParam> ? ExtractParamType<TParam> | undefined : TParams[K] extends RequiredUrlParam<infer TParam> ? ExtractParamType<TParam> : unknown;
 }>>;
 export {};

package/dist/types/utilities.d.ts

@@ -2,7 +2,6 @@ export type Identity<T> = T extends object ? {} & {
     [P in keyof T as T[P] extends never ? never : P]: T[P];
 } : T;
 type IsEmptyObject<T> = T extends Record<string, never> ? (keyof T extends never ? true : false) : false;
-export type MaybeArray<T> = T | T[];
 export type LastInArray<T, TFallback = never> = T extends [...any[], infer Last] ? Last : TFallback;
 export type MaybePromise<T> = T | Promise<T>;
 type OnlyRequiredProperties<T> = {

package/dist/utilities/array.d.ts

@@ -1,2 +1 @@
-export declare function asArray<T>(value: Readonly<T | T[]>): T[];
 export declare function getCount<T>(array: T[], item: T): number;