@kitbag/router 0.22.4 → 0.22.6

package/dist/services/createRouterHistory.d.ts

@@ -1,4 +1,4 @@
-import { History, Listener } from 'history';
+import { History, Listener } from './history';
 type NavigationPushOptions = {
     replace?: boolean;
     state?: unknown;

package/dist/services/getMatchesForUrl.d.ts

@@ -1,4 +1,7 @@
 import { ResolvedRoute } from '../types/resolved';
 import { Routes } from '../types/route';
 import { RouterResolveOptions } from '../types/routerResolve';
-export declare function getMatchForUrl(routes: Routes, url: string, options?: RouterResolveOptions): ResolvedRoute | undefined;
+import { ParseUrlOptions } from '../types/url';
+type MatchOptions = RouterResolveOptions & ParseUrlOptions;
+export declare function getMatchForUrl(routes: Routes, url: string, options?: MatchOptions): ResolvedRoute | undefined;
+export {};

package/dist/services/history.browser.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/history.d.ts

@@ -0,0 +1,59 @@
+export type Action = 'POP' | 'PUSH' | 'REPLACE';
+export type Pathname = string;
+export type Search = string;
+export type Hash = string;
+export type Key = string;
+export interface Path {
+    pathname: Pathname;
+    search: Search;
+    hash: Hash;
+}
+export interface Location extends Path {
+    state: unknown;
+    key: Key;
+}
+export interface Update {
+    action: Action;
+    location: Location;
+}
+export type Listener = (update: Update) => void;
+export interface Transition extends Update {
+    retry: () => void;
+}
+export type Blocker = (tx: Transition) => void;
+export type To = string | Partial<Path>;
+export interface History {
+    readonly action: Action;
+    readonly location: Location;
+    createHref: (to: To) => string;
+    push: (to: To, state?: unknown) => void;
+    replace: (to: To, state?: unknown) => void;
+    go: (delta: number) => void;
+    back: () => void;
+    forward: () => void;
+    listen: (listener: Listener) => () => void;
+    block: (blocker: Blocker) => () => void;
+}
+export interface BrowserHistory extends History {
+}
+export interface HashHistory extends History {
+}
+export interface MemoryHistory extends History {
+    readonly index: number;
+}
+export type BrowserHistoryOptions = {
+    window?: Window;
+};
+export type HashHistoryOptions = {
+    window?: Window;
+};
+export type InitialEntry = string | Partial<Location>;
+export type MemoryHistoryOptions = {
+    initialEntries?: InitialEntry[];
+    initialIndex?: number;
+};
+export declare function createPath({ pathname, search, hash }: Partial<Path>): string;
+export declare function parsePath(path: string): Partial<Path>;
+export declare function createBrowserHistory(options?: BrowserHistoryOptions): BrowserHistory;
+export declare function createHashHistory(options?: HashHistoryOptions): HashHistory;
+export declare function createMemoryHistory(options?: MemoryHistoryOptions): MemoryHistory;

package/dist/services/withParams.d.ts

@@ -1,19 +1,19 @@
-import { ExtractParamName, ParamEnd, ParamIsGreedy, ParamIsOptional, ParamStart } from '../types/params';
+import { ExtractParamName, ParamEnd, ParamIsGreedy, ParamIsOptionalOrHasDefault, 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 ? TParams[ExtractParamName<TParam>] extends Param ? Record<ExtractParamName<TParam>, {
     param: TParams[ExtractParamName<TParam>];
-    isOptional: ParamIsOptional<TParam>;
+    isOptional: ParamIsOptionalOrHasDefault<TParam, TParams[ExtractParamName<TParam>]>;
     isGreedy: ParamIsGreedy<TParam>;
 }> & WithParamsParamsOutput<Rest, TParams> : Record<ExtractParamName<TParam>, {
     param: StringConstructor;
-    isOptional: ParamIsOptional<TParam>;
+    isOptional: ParamIsOptionalOrHasDefault<TParam, TParams[ExtractParamName<TParam>]>;
     isGreedy: ParamIsGreedy<TParam>;
 }> & WithParamsParamsOutput<Rest, TParams> : Record<ExtractParamName<TParam>, {
     param: StringConstructor;
-    isOptional: ParamIsOptional<TParam>;
+    isOptional: ParamIsOptionalOrHasDefault<TParam, TParams[ExtractParamName<TParam>]>;
     isGreedy: ParamIsGreedy<TParam>;
 }> & WithParamsParamsOutput<Rest, TParams> : {};
 declare const UrlPartsWithParamsSymbol: unique symbol;
@@ -57,13 +57,13 @@ export type ToUrlQueryPart<T extends UrlQueryPart | string | undefined> = T exte
 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>;
+        isOptional: ParamIsOptionalOrHasDefault<K & string, T[K]>;
         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>;
+    isOptional: ParamIsOptionalOrHasDefault<TKey, TValue>;
     isGreedy: false;
 }> & QueryArrayToUrlPart<Rest>> : never : {};
 export declare function toUrlQueryPart<T extends UrlQueryPart | string | undefined>(querySource: T): ToUrlQueryPart<T>;

package/dist/types/createRouteOptions.d.ts

@@ -102,8 +102,9 @@ type RoutePropsRecord<TOptions extends CreateRouteOptions = CreateRouteOptions,
     [K in keyof TComponents as ComponentPropsAreOptional<TComponents[K]> extends false ? K : never]: PropsGetter<TOptions, TComponents[K]>;
 };
 export type CreateRouteProps<TOptions extends CreateRouteOptions = CreateRouteOptions> = TOptions['component'] extends Component ? PropsGetter<TOptions, TOptions['component']> : TOptions['components'] extends Record<string, Component> ? RoutePropsRecord<TOptions, TOptions['components']> : RouterViewPropsGetter<TOptions>;
-type ToMatch<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined> = Omit<TOptions, 'props' | 'meta'> & {
+type ToMatch<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined> = Omit<TOptions, 'props' | 'meta' | 'name'> & {
     id: string;
+    name: ToName<TOptions['name']>;
     props: TProps;
     /**
      * Represents additional metadata associated with a route. Always present, defaults to empty object.

package/dist/types/params.d.ts

@@ -36,3 +36,4 @@ export type ExtractParamName<TParam extends PropertyKey> = TParam extends string
 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;
+export type ParamIsOptionalOrHasDefault<TParamName extends string, TParam extends Param | undefined> = ParamIsOptional<TParamName> extends true ? true : TParam extends Required<ParamGetSet> ? true : false;

package/dist/types/router.d.ts

@@ -163,10 +163,11 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
     hasDevtools: boolean;
 };
 /**
- * This type is the same as `RouterRoute<ResolvedRoute<TRoutes[number]>>` while remaining distributive
+ * This type is the same as `RouterRoute<ResolvedRoute<TRoutes[number]>>` while remaining distributive.
+ * Routes without a name (empty string) are excluded so that router.route.name is never ''.
  */
 export type RouterRouteUnion<TRoutes extends Routes> = {
-    [K in keyof TRoutes]: RouterRoute<ResolvedRoute<TRoutes[K]>>;
+    [K in keyof TRoutes]: TRoutes[K]['name'] extends '' ? never : RouterRoute<ResolvedRoute<TRoutes[K]>>;
 }[number];
 export type RouterRoutes<TRouter extends Router> = TRouter extends Router<infer TRoutes extends Routes> ? TRoutes : Routes;
 export type RouterRejections<TRouter extends Router> = TRouter extends Router<any, infer TOptions extends RouterOptions, infer TPlugins extends RouterPlugin> ? ExtractRejections<TOptions> | ExtractRejections<TPlugins> : [];

package/dist/types/url.d.ts

@@ -19,6 +19,13 @@ export type ToUrl<TOptions extends CreateUrlOptions> = Url<Identity<ToUrlPart<TO
 export declare function isUrlWithSchema(url: unknown): url is Url & {
     schema: Record<string, UrlPart>;
 };
+export type ParseUrlOptions = {
+    /**
+     * Whether to remove trailing slashes from the path. When true, trailing slashes will be removed from the path.
+     * @default true
+     */
+    removeTrailingSlashes?: boolean;
+};
 /**
  * Represents the structure of a url parts. Can be used to create a url with support for params.
  */
@@ -35,11 +42,11 @@ export type Url<TParams extends UrlParams = UrlParams> = {
     /**
      * Parses the url supplied and returns any params found.
      */
-    parse(url: string): ToUrlParamsReading<TParams>;
+    parse(url: string, options?: ParseUrlOptions): ToUrlParamsReading<TParams>;
     /**
      * Parses the url supplied and returns any params found.
      */
-    tryParse(url: string): {
+    tryParse(url: string, options?: ParseUrlOptions): {
         success: true;
         params: ToUrlParamsReading<TParams>;
     } | {

package/dist/utilities/guards.d.ts

@@ -1,5 +1,6 @@
 export declare function isDefined<T>(value: T | undefined): value is T;
 export declare function isRecord(value: unknown): value is Record<PropertyKey, unknown>;
+export declare function isPropertyKey(value: unknown): value is PropertyKey;
 export declare function hasProperty<TSource extends Record<PropertyKey, unknown>, TProperty extends PropertyKey, TType extends () => unknown>(value: TSource, key: TProperty, type?: TType): value is TSource & Record<TProperty, ReturnType<TType>>;
 export declare function stringHasValue(value: string | undefined): value is string;
 export type StringHasValue<T> = string extends T ? true : '' extends T ? false : T extends string ? true : false;