@esportsplus/routing 0.2.7 → 0.3.1

package/.github/workflows/publish.yml

@@ -12,5 +12,5 @@ on:
 jobs:
   publish:
     secrets:
-        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN_PUBLISHING }}
-    uses: esportsplus/workflows/.github/workflows/publish.yml@main
+        NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+    uses: esportsplus/workflows/.github/workflows/publish.yml@main

package/build/browser.d.ts

@@ -1,16 +1,17 @@
-import { Middleware, Next, Request, Route, Router } from './types.js';
+import { Middleware, Next, PathParamsTuple, Request, Route, Router, RouteRegistry } from './types.js';
+import { Router as RouterClass } from './router/index.js';
 declare function back(): void;
 declare function forward(): void;
-declare const _default: <T>(instance?: Router<T>) => {
+declare const _default: <T, TRoutes extends RouteRegistry = {}>(instance?: RouterClass<T, TRoutes>) => {
     back: typeof back;
     forward: typeof forward;
     middleware: {
-        (...middleware: Middleware<T>[]): T;
+        (...middleware: Middleware<T>[]): import("@esportsplus/pipeline").Pipeline<Request<T>, T>;
         dispatch(request: Request<T>): T;
         match(fallback: Route<T>): (request: Request<T>, next: Next<T>) => T;
     };
-    redirect: (path: string, values?: unknown[]) => void;
-    router: Router<T>;
-    uri: (path: string, values?: unknown[]) => string;
+    redirect: <TName extends keyof TRoutes & string>(name: TName, values?: PathParamsTuple<TRoutes[TName]["path"]>) => void;
+    router: Router<T, TRoutes>;
+    uri: <TName extends keyof TRoutes & string>(name: TName, values?: PathParamsTuple<TRoutes[TName]["path"]>) => string;
 };
 export default _default;

package/build/browser.js

@@ -1,5 +1,5 @@
 import { effect, reactive, root } from '@esportsplus/reactivity';
-import { next } from '@esportsplus/pipeline';
+import pipeline from '@esportsplus/pipeline';
 import factory from './router/index.js';
 let cache = [], location = window.location;
 function back() {
@@ -10,8 +10,8 @@ function forward() {
 }
 function href() {
     let hash = location.hash || '#/', path = hash ? hash.slice(1).split('?') : ['/', ''], request = {
-        href: location.href,
         hostname: location.hostname,
+        href: location.href,
         method: 'GET',
         origin: location.origin,
         path: path[0],
@@ -20,7 +20,7 @@ function href() {
         query: {}
     };
     if (path[1]) {
-        let query = request.query, params = new URLSearchParams(path[1]);
+        let params = new URLSearchParams(path[1]), query = request.query;
         for (let [key, value] of params.entries()) {
             query[key] = value;
         }
@@ -42,7 +42,7 @@ function match(request, router, subdomain) {
 }
 function middleware(request, router) {
     function host(...middleware) {
-        return middleware[0](request, next(1, middleware));
+        return pipeline(middleware);
     }
     ;
     host.dispatch = (request) => {
@@ -104,15 +104,15 @@ export default (instance) => {
         back,
         forward,
         middleware: middleware(request, router),
-        redirect: (path, values = []) => {
-            if (path.indexOf('://') !== -1) {
-                return window.location.replace(path);
+        redirect: (name, values = []) => {
+            if (name.indexOf('://') !== -1) {
+                return window.location.replace(name);
             }
-            window.location.hash = normalize(router.uri(path, values));
+            window.location.hash = normalize(router.uri(name, values));
         },
         router,
-        uri: (path, values = []) => {
-            return normalize(router.uri(path, values));
+        uri: (name, values = []) => {
+            return normalize(router.uri(name, values));
         }
     };
 };

package/build/router/index.d.ts

@@ -1,7 +1,7 @@
-import { Name, Options, Route, RouteOptions } from '../types.js';
+import { Name, Options, PathParamsTuple, Route, RouteOptions, RouteRegistry } from '../types.js';
 import { Node } from './node.js';
 declare function key(method: string, subdomain?: string | null): string;
-declare class Router<T> {
+declare class Router<T, TRoutes extends RouteRegistry = {}> {
     bucket: Record<ReturnType<typeof key>, {
         root: Node<T>;
         static: Record<string, Route<T>>;
@@ -10,22 +10,57 @@ declare class Router<T> {
     routes: Record<Name, Route<T>>;
     subdomains: string[] | null;
     private add;
-    private route;
-    delete(options: RouteOptions<T>): this;
-    get(options: RouteOptions<T>): this;
+    private create;
+    delete<TName extends string = string, TPath extends string = string>(options: RouteOptions<T> & {
+        name?: TName;
+        path?: TPath;
+    }): Router<T, TRoutes & (TName extends string ? TPath extends string ? {
+        [K in TName]: {
+            path: TPath;
+        };
+    } : TRoutes : TRoutes)>;
+    get<TName extends string = string, TPath extends string = string>(options: RouteOptions<T> & {
+        name?: TName;
+        path?: TPath;
+    }): Router<T, TRoutes & (TName extends string ? TPath extends string ? {
+        [K in TName]: {
+            path: TPath;
+        };
+    } : TRoutes : TRoutes)>;
     group(options: Options<T>): {
-        routes: (fn: (router: Router<T>) => void) => void;
+        routes: (fn: (router: Router<T, TRoutes>) => void) => Router<T, TRoutes>;
     };
     match(method: string, path: string, subdomain?: string | null): {
         parameters?: Readonly<Record<PropertyKey, unknown>>;
         route?: Readonly<Route<T>> | undefined;
     };
-    on(methods: string[], options: RouteOptions<T>): this;
-    post(options: RouteOptions<T>): this;
-    put(options: RouteOptions<T>): this;
-    uri(name: Name, values?: unknown[]): string;
+    on<TName extends string = string, TPath extends string = string>(methods: string[], options: RouteOptions<T> & {
+        name?: TName;
+        path?: TPath;
+    }): Router<T, TRoutes & (TName extends string ? TPath extends string ? {
+        [K in TName]: {
+            path: TPath;
+        };
+    } : TRoutes : TRoutes)>;
+    post<TName extends string = string, TPath extends string = string>(options: RouteOptions<T> & {
+        name?: TName;
+        path?: TPath;
+    }): Router<T, TRoutes & (TName extends string ? TPath extends string ? {
+        [K in TName]: {
+            path: TPath;
+        };
+    } : TRoutes : TRoutes)>;
+    put<TName extends string = string, TPath extends string = string>(options: RouteOptions<T> & {
+        name?: TName;
+        path?: TPath;
+    }): Router<T, TRoutes & (TName extends string ? TPath extends string ? {
+        [K in TName]: {
+            path: TPath;
+        };
+    } : TRoutes : TRoutes)>;
+    uri<TName extends keyof TRoutes & string>(name: TName, values?: PathParamsTuple<TRoutes[TName]['path']>): string;
 }
-declare const _default: <T>() => Router<T>;
+declare const _default: <T>() => Router<T, {}>;
 export default _default;
 export { Router };
 export type { Route };

package/build/router/index.js

@@ -53,7 +53,7 @@ class Router {
         }
         return this;
     }
-    route(options) {
+    create(options) {
         let groups = this.groups, route = {
             name: null,
             path: null,
@@ -73,10 +73,12 @@ class Router {
         return route;
     }
     delete(options) {
-        return this.on(ON_DELETE, options);
+        this.on(ON_DELETE, options);
+        return this;
     }
     get(options) {
-        return this.on(ON_GET, options);
+        this.on(ON_GET, options);
+        return this;
     }
     group(options) {
         return {
@@ -84,6 +86,7 @@ class Router {
                 this.groups.push(options);
                 fn(this);
                 this.groups.pop();
+                return this;
             }
         };
     }
@@ -99,7 +102,7 @@ class Router {
         return bucket.root.find(path);
     }
     on(methods, options) {
-        let route = this.route(options);
+        let route = this.create(options);
         let name = route.name, path = route.path, subdomain = route.subdomain;
         if (name) {
             if (this.routes[name]) {
@@ -129,10 +132,12 @@ class Router {
         return this;
     }
     post(options) {
-        return this.on(ON_POST, options);
+        this.on(ON_POST, options);
+        return this;
     }
     put(options) {
-        return this.on(ON_PUT, options);
+        this.on(ON_PUT, options);
+        return this;
     }
     uri(name, values = []) {
         let path = this.routes[name]?.path;

package/build/types.d.ts

@@ -1,6 +1,10 @@
 import { NeverAsync } from '@esportsplus/utilities';
 import { Router } from './router/index.js';
 import pipeline from '@esportsplus/pipeline';
+type ExtractOptionalParamsTuple<Path extends string> = Path extends `${infer _Start}?:${infer Param}/${infer Rest}` ? [Param, ...ExtractOptionalParamsTuple<`/${Rest}`>] : Path extends `${infer _Start}?:${infer Param}` ? [Param] : [];
+type ExtractParamsTuple<Path extends string> = Path extends `${infer _Start}:${infer Param}/${infer Rest}` ? [Param, ...ExtractParamsTuple<`/${Rest}`>] : Path extends `${infer _Start}:${infer Param}` ? [Param] : [];
+type ExtractWildcard<Path extends string> = Path extends `${string}*:${infer Param}` ? Param : never;
+type LabeledParamsTuple<Params extends string[]> = Params extends [infer _First extends string, ...infer Rest extends string[]] ? [_First: string | number, ...LabeledParamsTuple<Rest>] : [];
 type Middleware<T> = NeverAsync<(input: Request<T>, next: Next<T>) => T>;
 type Name = string;
 type Next<T> = NeverAsync<(input: Request<T>) => T>;
@@ -10,6 +14,11 @@ type Options<T> = {
     path?: string;
     subdomain?: string;
 };
+type PathParamsTuple<Path extends string> = LabeledParamsTuple<ExtractParamsTuple<Path>>;
+type PathParamsTupleWithOptional<Path extends string> = [
+    ...LabeledParamsTuple<ExtractParamsTuple<Path>>,
+    ...Partial<LabeledParamsTuple<ExtractOptionalParamsTuple<Path>>>
+];
 type Request<T> = {
     data: Record<PropertyKey, unknown> & ReturnType<Router<T>['match']>;
     href: string;
@@ -31,4 +40,7 @@ type Route<T> = {
 type RouteOptions<T> = Options<T> & {
     responder: Next<T>;
 };
-export type { Middleware, Name, Next, Options, Request, Route, RouteOptions, Router };
+type RouteRegistry = Record<string, {
+    path: string;
+}>;
+export type { ExtractOptionalParamsTuple, ExtractParamsTuple, ExtractWildcard, LabeledParamsTuple, Middleware, Name, Next, Options, PathParamsTuple, PathParamsTupleWithOptional, Request, Route, RouteOptions, Router, RouteRegistry };

package/package.json

@@ -1,9 +1,9 @@
 {
   "author": "ICJR",
   "dependencies": {
-    "@esportsplus/pipeline": "^1.1.5",
-    "@esportsplus/reactivity": "^0.18.0",
-    "@esportsplus/utilities": "^0.22.2"
+    "@esportsplus/pipeline": "^1.2.0",
+    "@esportsplus/reactivity": "^0.22.1",
+    "@esportsplus/utilities": "^0.26.0"
   },
   "devDependencies": {
     "@esportsplus/typescript": "^0.9.2"
@@ -11,10 +11,14 @@
   "main": "./build/index.js",
   "name": "@esportsplus/routing",
   "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/esportsplus/routing"
+  },
   "type": "module",
   "sideEffects": false,
   "types": "./build/index.d.ts",
-  "version": "0.2.7",
+  "version": "0.3.1",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-",

package/src/browser.ts

@@ -1,6 +1,7 @@
 import { effect, reactive, root } from '@esportsplus/reactivity';
-import { Middleware, Next, Request, Route, Router } from './types';
-import { next } from '@esportsplus/pipeline';
+import pipeline from '@esportsplus/pipeline';
+import { Middleware, Next, PathParamsTuple, Request, Route, Router, RouteRegistry } from './types';
+import { Router as RouterClass } from './router';
 import factory from './router';
 
 
@@ -20,8 +21,8 @@ function href<T>() {
     let hash = location.hash || '#/',
         path = hash ? hash.slice(1).split('?') : ['/', ''],
         request = {
-            href: location.href,
             hostname: location.hostname,
+            href: location.href,
             method: 'GET',
             origin: location.origin,
             path: path[0],
@@ -31,8 +32,8 @@ function href<T>() {
         };
 
     if (path[1]) {
-        let query = request.query,
-            params = new URLSearchParams(path[1]);
+        let params = new URLSearchParams(path[1]),
+            query = request.query;
 
         for (let [key, value] of params.entries()) {
             query[key] = value;
@@ -62,7 +63,7 @@ function match<T>(request: Request<T>, router: Router<T>, subdomain?: string) {
 
 function middleware<T>(request: Request<T>, router: Router<T>) {
     function host(...middleware: Middleware<T>[]) {
-        return middleware[0](request, next(1, middleware));
+        return pipeline(middleware);
     };
 
     host.dispatch = (request: Request<T>) => {
@@ -133,9 +134,9 @@ function onpopstate() {
 }
 
 
-export default <T>(instance?: Router<T>) => {
+export default <T, TRoutes extends RouteRegistry = {}>(instance?: RouterClass<T, TRoutes>) => {
     let request = reactive( Object.assign(href<T>(), { data: {} } as any) as Request<T> ),
-        router = instance || factory<T>();
+        router = instance || factory<T>() as RouterClass<T, TRoutes>;
 
     if (cache.push(request) === 1) {
         window.addEventListener('hashchange', onpopstate);
@@ -144,17 +145,23 @@ export default <T>(instance?: Router<T>) => {
     return {
         back,
         forward,
-        middleware: middleware(request, router),
-        redirect: (path: string, values: unknown[] = []) => {
-            if (path.indexOf('://') !== -1) {
-                return window.location.replace(path);
+        middleware: middleware(request, router as Router<T>),
+        redirect: <TName extends keyof TRoutes & string>(
+            name: TName,
+            values: PathParamsTuple<TRoutes[TName]['path']> = [] as any
+        ) => {
+            if ((name as string).indexOf('://') !== -1) {
+                return window.location.replace(name);
             }
 
-            window.location.hash = normalize( router.uri(path, values) );
+            window.location.hash = normalize( router.uri(name, values) );
         },
         router,
-        uri: (path: string, values: unknown[] = []) => {
-            return normalize( router.uri(path, values) );
+        uri: <TName extends keyof TRoutes & string>(
+            name: TName,
+            values: PathParamsTuple<TRoutes[TName]['path']> = [] as any
+        ) => {
+            return normalize( router.uri(name, values) );
         }
     };
 };

package/src/router/index.ts

@@ -1,5 +1,5 @@
 import { ON_DELETE, ON_GET, ON_POST, ON_PUT } from '../constants';
-import { Name, Options, Request, Route, RouteOptions } from '../types';
+import { Name, Options, PathParamsTuple, Request, Route, RouteOptions, RouteRegistry } from '../types';
 import { Node } from './node';
 import pipeline from '@esportsplus/pipeline';
 
@@ -44,7 +44,7 @@ function set<T>(route: Route<T>, options: Options<T> | RouteOptions<T>) {
 }
 
 
-class Router<T> {
+class Router<T, TRoutes extends RouteRegistry = {}> {
     bucket: Record<ReturnType<typeof key>, { root: Node<T>, static: Record<string, Route<T>> }> = {};
     groups: Options<T>[] = [];
     routes: Record<Name, Route<T>> = {};
@@ -71,7 +71,7 @@ class Router<T> {
         return this;
     }
 
-    private route(options: RouteOptions<T>) {
+    private create(options: RouteOptions<T>) {
         let groups = this.groups,
             route: Route<T> = {
                 name: null,
@@ -98,22 +98,31 @@ class Router<T> {
     }
 
 
-    delete(options: RouteOptions<T>) {
-        return this.on(ON_DELETE, options);
+    delete<TName extends string = string, TPath extends string = string>(
+        options: RouteOptions<T> & { name?: TName; path?: TPath }
+    ): Router<T, TRoutes & (TName extends string ? TPath extends string ? { [K in TName]: { path: TPath } } : TRoutes : TRoutes)> {
+        this.on(ON_DELETE, options);
+        return this as any;
     }
 
-    get(options: RouteOptions<T>) {
-        return this.on(ON_GET, options);
+    get<TName extends string = string, TPath extends string = string>(
+        options: RouteOptions<T> & { name?: TName; path?: TPath }
+    ): Router<T, TRoutes & (TName extends string ? TPath extends string ? { [K in TName]: { path: TPath } } : TRoutes : TRoutes)> {
+        this.on(ON_GET, options);
+        return this as any;
     }
 
-    group(options: Options<T>) {
+    group(options: Options<T>): {
+        routes: (fn: (router: Router<T, TRoutes>) => void) => Router<T, TRoutes>
+    } {
         return {
-            routes: (fn: (router: Router<T>) => void) => {
+            routes: (fn: (router: Router<T, TRoutes>) => void) => {
                 this.groups.push(options);
                 fn(this);
                 this.groups.pop();
+                return this;
             }
-        }
+        };
     }
 
     match(method: string, path: string, subdomain?: string | null) {
@@ -132,8 +141,11 @@ class Router<T> {
         return bucket.root.find(path);
     }
 
-    on(methods: string[], options: RouteOptions<T>) {
-        let route = this.route(options);
+    on<TName extends string = string, TPath extends string = string>(
+        methods: string[],
+        options: RouteOptions<T> & { name?: TName; path?: TPath }
+    ): Router<T, TRoutes & (TName extends string ? TPath extends string ? { [K in TName]: { path: TPath } } : TRoutes : TRoutes)> {
+        let route = this.create(options);
 
         let name = route.name,
             path = route.path,
@@ -172,25 +184,34 @@ class Router<T> {
             (this.subdomains ??= []).push( subdomain.toLowerCase() );
         }
 
-        return this;
+        return this as any;
     }
 
-    post(options: RouteOptions<T>) {
-        return this.on(ON_POST, options);
+    post<TName extends string = string, TPath extends string = string>(
+        options: RouteOptions<T> & { name?: TName; path?: TPath }
+    ): Router<T, TRoutes & (TName extends string ? TPath extends string ? { [K in TName]: { path: TPath } } : TRoutes : TRoutes)> {
+        this.on(ON_POST, options);
+        return this as any;
     }
 
-    put(options: RouteOptions<T>) {
-        return this.on(ON_PUT, options);
+    put<TName extends string = string, TPath extends string = string>(
+        options: RouteOptions<T> & { name?: TName; path?: TPath }
+    ): Router<T, TRoutes & (TName extends string ? TPath extends string ? { [K in TName]: { path: TPath } } : TRoutes : TRoutes)> {
+        this.on(ON_PUT, options);
+        return this as any;
     }
 
-    uri(name: Name, values: unknown[] = []) {
+    uri<TName extends keyof TRoutes & string>(
+        name: TName,
+        values: PathParamsTuple<TRoutes[TName]['path']> = [] as any
+    ): string {
         let path = this.routes[name]?.path;
 
         if (!path) {
             throw new Error(`Routing: route name '${name}' does not exist or it does not provide a path`);
         }
 
-        let resolved = [] as typeof values,
+        let resolved: (string | number)[] = [],
             segments = path.split('/'),
             v = 0;
 
@@ -199,18 +220,18 @@ class Router<T> {
                 symbol = segment[0];
 
             if (symbol === ':') {
-                resolved.push(values[v++]);
+                resolved.push((values as (string | number)[])[v++]);
             }
             else if (symbol === '?') {
-                if (values[v] === undefined) {
+                if ((values as (string | number)[])[v] === undefined) {
                     break;
                 }
 
-                resolved.push(values[v++]);
+                resolved.push((values as (string | number)[])[v++]);
             }
             else if (symbol === '*') {
                 for (let n = values.length; v < n; v++) {
-                    resolved.push( values[v] );
+                    resolved.push((values as (string | number)[])[v]);
                 }
                 break;
             }
@@ -224,6 +245,6 @@ class Router<T> {
 }
 
 
-export default <T>() => new Router<T>();
+export default <T>() => new Router<T, {}>();
 export { Router };
 export type { Route };

package/src/types.ts

@@ -3,6 +3,30 @@ import { Router } from './router';
 import pipeline from '@esportsplus/pipeline';
 
 
+type ExtractOptionalParamsTuple<Path extends string> =
+    Path extends `${infer _Start}?:${infer Param}/${infer Rest}`
+        ? [Param, ...ExtractOptionalParamsTuple<`/${Rest}`>]
+        : Path extends `${infer _Start}?:${infer Param}`
+            ? [Param]
+            : [];
+
+type ExtractParamsTuple<Path extends string> =
+    Path extends `${infer _Start}:${infer Param}/${infer Rest}`
+        ? [Param, ...ExtractParamsTuple<`/${Rest}`>]
+        : Path extends `${infer _Start}:${infer Param}`
+            ? [Param]
+            : [];
+
+type ExtractWildcard<Path extends string> =
+    Path extends `${string}*:${infer Param}`
+        ? Param
+        : never;
+
+type LabeledParamsTuple<Params extends string[]> =
+    Params extends [infer _First extends string, ...infer Rest extends string[]]
+        ? [_First: string | number, ...LabeledParamsTuple<Rest>]
+        : [];
+
 type Middleware<T> = NeverAsync<(input: Request<T>, next: Next<T>) => T>;
 
 type Name = string;
@@ -16,6 +40,12 @@ type Options<T> = {
     subdomain?: string;
 };
 
+type PathParamsTuple<Path extends string> =
+    LabeledParamsTuple<ExtractParamsTuple<Path>>;
+
+type PathParamsTupleWithOptional<Path extends string> =
+    [...LabeledParamsTuple<ExtractParamsTuple<Path>>, ...Partial<LabeledParamsTuple<ExtractOptionalParamsTuple<Path>>>];
+
 type Request<T> = {
     data: Record<PropertyKey, unknown> & ReturnType<Router<T>['match']>;
     href: string;
@@ -40,10 +70,23 @@ type RouteOptions<T> = Options<T> & {
     responder: Next<T>;
 };
 
+type RouteRegistry = Record<string, { path: string }>;
+
 
 export type {
+    ExtractOptionalParamsTuple,
+    ExtractParamsTuple,
+    ExtractWildcard,
+    LabeledParamsTuple,
     Middleware,
-    Name, Next,
+    Name,
+    Next,
     Options,
-    Request, Route, RouteOptions, Router
+    PathParamsTuple,
+    PathParamsTupleWithOptional,
+    Request,
+    Route,
+    RouteOptions,
+    Router,
+    RouteRegistry
 };