@esportsplus/routing 0.0.49 → 0.1.1

package/build/browser.d.ts

@@ -1,4 +1,3 @@
-import { Scheduler } from '@esportsplus/reactivity';
 import { Middleware, Next, Request, Route, Router } from './types';
 declare function back(): void;
 declare function forward(): void;
@@ -6,9 +5,9 @@ declare const _default: <T>(instance?: Router<T>) => {
     back: typeof back;
     forward: typeof forward;
     middleware: {
-        (...middleware: Middleware<T>[]): () => T;
+        (...middleware: Middleware<T>[]): T;
         dispatch(request: Request<T>): T;
-        match(fallback: Route<T>, scheduler: Scheduler, subdomain?: string | undefined): (request: Request<T>, next: Next<T>) => T;
+        match(fallback: Route<T>): (request: Request<T>, next: Next<T>) => T;
     };
     redirect: (path: string, values?: unknown[]) => void;
     router: Router<T>;

package/build/browser.js

@@ -1,5 +1,5 @@
 import { effect, reactive, root } from '@esportsplus/reactivity';
-import pipeline from '@esportsplus/pipeline';
+import { next } from '@esportsplus/pipeline';
 import factory from './router';
 let cache = [];
 function back() {
@@ -40,28 +40,27 @@ function match(request, router, subdomain) {
 }
 function middleware(request, router) {
     function host(...middleware) {
-        let instance = pipeline(...middleware);
-        return () => instance(request);
+        return middleware[0](request, next(1, middleware));
     }
     ;
     host.dispatch = (request) => {
         let { route } = request.data;
         if (route === undefined) {
-            throw new Error(`Middleware: route is undefined!`);
+            throw new Error(`Routing: route is undefined!`);
         }
-        return route.dispatch(request);
+        return route.pipeline.dispatch(request);
     };
-    host.match = (fallback, scheduler, subdomain) => {
+    host.match = (fallback) => {
         let state = reactive({
             parameters: undefined,
             root: undefined,
             route: undefined
         });
         if (fallback === undefined) {
-            throw new Error('Middleware: fallback route does not exist');
+            throw new Error('Routing: fallback route does not exist');
         }
         effect(() => {
-            let { parameters, route } = match(request, router, subdomain);
+            let { parameters, route } = match(request, router);
             state.parameters = parameters;
             state.route = route || fallback;
         });
@@ -79,7 +78,7 @@ function middleware(request, router) {
                 };
                 state.root = root;
                 return next(request);
-            }, scheduler);
+            });
         };
     };
     return host;

package/build/constants.d.ts

@@ -1,4 +1,8 @@
+declare const ON_DELETE: string[];
+declare const ON_GET: string[];
+declare const ON_POST: string[];
+declare const ON_PUT: string[];
 declare const PLACEHOLDER = 0;
 declare const STATIC = 1;
 declare const WILDCARD = 2;
-export { PLACEHOLDER, STATIC, WILDCARD };
+export { ON_DELETE, ON_GET, ON_POST, ON_PUT, PLACEHOLDER, STATIC, WILDCARD };

package/build/constants.js

@@ -1,4 +1,8 @@
+const ON_DELETE = ['DELETE'];
+const ON_GET = ['GET'];
+const ON_POST = ['POST'];
+const ON_PUT = ['PUT'];
 const PLACEHOLDER = 0;
 const STATIC = 1;
 const WILDCARD = 2;
-export { PLACEHOLDER, STATIC, WILDCARD };
+export { ON_DELETE, ON_GET, ON_POST, ON_PUT, PLACEHOLDER, STATIC, WILDCARD };

package/build/index.d.ts

@@ -1,6 +1,4 @@
-import browser from './browser';
-import router from './router';
-import { Router as R2 } from './router2';
-import slugify from './slugify';
-export { browser, router, slugify, R2 };
+export { default as browser } from './browser';
+export { default as router } from './router';
+export { default as slugify } from './slugify';
 export * from './types';

package/build/index.js

@@ -1,6 +1,4 @@
-import browser from './browser';
-import router from './router';
-import { Router as R2 } from './router2';
-import slugify from './slugify';
-export { browser, router, slugify, R2 };
+export { default as browser } from './browser';
+export { default as router } from './router';
+export { default as slugify } from './slugify';
 export * from './types';

package/build/router/index.d.ts

@@ -1,25 +1,27 @@
-import { Options } from '../types';
+import { Name, Options, Route, RouteOptions } from '../types';
 import { Node } from './node';
-import { Route } from './route';
 declare class Router<T> {
-    groups: Omit<Options<T>, 'responder'>[];
+    groups: Options<T>[];
     root: Node<T>;
-    routes: Record<string, Route<T>>;
-    static: Record<string, Route<T>>;
+    routes: Record<Name, Route<T>>;
+    static: Record<Name, Route<T>>;
     subdomains: string[] | null;
     constructor();
     private add;
     private route;
-    delete(options: Options<T>): this;
-    get(options: Options<T>): this;
-    group(options: Router<T>['groups'][0]): {
+    delete(options: RouteOptions<T>): this;
+    get(options: RouteOptions<T>): this;
+    group(options: Options<T>): {
         routes: (fn: (router: Router<T>) => void) => void;
     };
-    match(method: string, path: string, subdomain?: string | null): ReturnType<Node<T>['find']>;
-    on(methods: string[], options: Options<T>): this;
-    post(options: Options<T>): this;
-    put(options: Options<T>): this;
-    uri(name: string, values?: unknown[]): string;
+    match(method: string, path: string, subdomain?: string | null): {
+        parameters?: Readonly<Record<PropertyKey, unknown>> | undefined;
+        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;
 }
 declare const _default: <T>() => Router<T>;
 export default _default;

package/build/router/index.js

@@ -1,12 +1,11 @@
-import { STATIC } from '../constants';
+import { ON_DELETE, ON_GET, ON_POST, ON_PUT, STATIC } from '../constants';
 import { Node } from './node';
-import { Route } from './route';
-let { isArray } = Array;
+import pipeline from '@esportsplus/pipeline';
 function normalize(path) {
     if (path[0] !== '/') {
         path = '/' + path;
     }
-    if (path[path.length - 1] === '/') {
+    if (path.at(-1) === '/') {
         path = path.slice(0, -1);
     }
     return path || '/';
@@ -14,21 +13,19 @@ function normalize(path) {
 function radixkey(method, path, subdomain) {
     return ((subdomain ? subdomain + ' ' : '') + method).toUpperCase() + ' ' + normalize(path);
 }
-function set(route, key, value) {
-    if (!value) {
-        return;
-    }
-    if (!route[key]) {
-        route[key] = value;
-    }
-    else if (typeof value === 'string') {
-        if (typeof route[key] === 'string') {
-            route[key] += value;
+function set(route, options) {
+    for (let key in options) {
+        let value = options[key];
+        if (key === 'middleware') {
+            for (let i = 0, n = value.length; i < n; i++) {
+                route.pipeline.add(value[i]);
+            }
         }
-    }
-    else if (isArray(value)) {
-        if (isArray(route[key])) {
-            route[key].push(...value);
+        else if (key === 'responder') {
+            route.pipeline.add(value);
+        }
+        else {
+            route[key] = (route[key] || '') + value;
         }
     }
 }
@@ -50,19 +47,17 @@ class Router {
         }
         return this;
     }
-    route({ middleware, name, path, responder, subdomain }) {
-        let route = new Route(responder);
-        for (let i = 0, n = this.groups.length; i < n; i++) {
-            let { middleware, name, path, subdomain } = this.groups[i];
-            set(route, 'name', name);
-            set(route, 'middleware', middleware);
-            set(route, 'path', path);
-            set(route, 'subdomain', subdomain);
+    route(options) {
+        let groups = this.groups, route = {
+            name: null,
+            path: null,
+            pipeline: pipeline(),
+            subdomain: null
+        };
+        for (let i = 0, n = groups.length; i < n; i++) {
+            set(route, groups[i]);
         }
-        set(route, 'name', name);
-        set(route, 'middleware', middleware);
-        set(route, 'path', path);
-        set(route, 'subdomain', subdomain);
+        set(route, options);
         if (route.path) {
             route.path = normalize(route.path);
         }
@@ -72,10 +67,10 @@ class Router {
         return route;
     }
     delete(options) {
-        return this.on(['DELETE'], options);
+        return this.on(ON_DELETE, options);
     }
     get(options) {
-        return this.on(['GET'], options);
+        return this.on(ON_GET, options);
     }
     group(options) {
         return {
@@ -128,10 +123,10 @@ class Router {
         return this;
     }
     post(options) {
-        return this.on(['POST'], options);
+        return this.on(ON_POST, options);
     }
     put(options) {
-        return this.on(['PUT'], options);
+        return this.on(ON_PUT, options);
     }
     uri(name, values = []) {
         let path = this.routes[name]?.path;
@@ -151,7 +146,9 @@ class Router {
                 resolved.push(values[i]);
             }
             else if (symbol === '*') {
-                resolved.push(...values.slice(i));
+                for (let n = values.length; i < n; i++) {
+                    resolved.push(values[i]);
+                }
                 break;
             }
             else {
@@ -162,4 +159,4 @@ class Router {
     }
 }
 export default () => new Router();
-export { Router, Route };
+export { Router };

package/build/router/node.d.ts

@@ -9,8 +9,8 @@ declare class Node<T> {
     constructor(parent?: Node<T>['parent']);
     add(path: string, route: Route<T>): Node<T>;
     find(path: string): {
-        parameters?: Record<PropertyKey, unknown>;
-        route?: Route<T>;
+        parameters?: Readonly<Record<PropertyKey, unknown>>;
+        route?: Readonly<Route<T>>;
     };
     remove(path: string): void;
 }

package/build/router/node.js

@@ -59,7 +59,7 @@ class Node {
                 parameters[node.property] = segment;
             }
         }
-        if ((!node || !node.route) && wildcard) {
+        if ((node === undefined || node.route === null) && wildcard !== null) {
             node = wildcard.node;
             parameters[node.property] = wildcard.value;
         }

package/build/types.d.ts

@@ -1,12 +1,13 @@
 import { NeverAsync } from '@esportsplus/typescript';
-import { Route, Router } from './router';
+import { Router } from './router';
+import pipeline from '@esportsplus/pipeline';
 type Middleware<T> = NeverAsync<(input: Request<T>, next: Next<T>) => T>;
+type Name = string;
 type Next<T> = NeverAsync<(input: Request<T>) => T>;
 type Options<T> = {
     middleware?: Middleware<T>[];
     name?: string;
     path?: string;
-    responder: Next<T>;
     subdomain?: string;
 };
 type Request<T> = {
@@ -21,4 +22,13 @@ type Request<T> = {
     query: Record<string, unknown>;
     subdomain?: string;
 };
-export { Middleware, Next, Options, Request, Route, Router };
+type Route<T> = {
+    name: Name | null;
+    path: string | null;
+    pipeline: ReturnType<typeof pipeline<Request<T>, T>>;
+    subdomain: string | null;
+};
+type RouteOptions<T> = Options<T> & {
+    responder: Next<T>;
+};
+export { Middleware, Name, Next, Options, Request, Route, RouteOptions, Router };

package/build/types.js

@@ -1,2 +1,2 @@
-import { Route, Router } from './router';
-export { Route, Router };
+import { Router } from './router';
+export { Router };

package/package.json

@@ -1,7 +1,7 @@
 {
     "author": "ICJR",
     "dependencies": {
-        "@esportsplus/pipeline": "^0.0.6",
+        "@esportsplus/pipeline": "^1.1.0",
         "@esportsplus/reactivity": "^0.1.21"
     },
     "devDependencies": {
@@ -17,5 +17,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "./build/index.d.ts",
-    "version": "0.0.49"
+    "version": "0.1.1"
 }

package/src/browser.ts

@@ -1,6 +1,6 @@
-import { effect, reactive, root, Root, Scheduler } from '@esportsplus/reactivity';
+import { effect, reactive, root, Root } from '@esportsplus/reactivity';
 import { Middleware, Next, Request, Route, Router } from './types';
-import pipeline from '@esportsplus/pipeline';
+import { next } from '@esportsplus/pipeline';
 import factory from './router';
 
 
@@ -55,22 +55,20 @@ 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>[]) {
-        let instance = pipeline(...middleware);
-
-        return () => instance(request);
+        return middleware[0](request, next(1, middleware));
     };
 
     host.dispatch = (request: Request<T>) => {
         let { route } = request.data;
 
         if (route === undefined) {
-            throw new Error(`Middleware: route is undefined!`);
+            throw new Error(`Routing: route is undefined!`);
         }
 
-        return route.dispatch(request);
+        return route.pipeline.dispatch(request);
     };
 
-    host.match = (fallback: Route<T>, scheduler: Scheduler, subdomain?: string) => {
+    host.match = (fallback: Route<T>) => {
         let state = reactive<ReturnType<typeof router.match> & { root?: Root }>({
                 parameters: undefined,
                 root: undefined,
@@ -78,11 +76,11 @@ function middleware<T>(request: Request<T>, router: Router<T>) {
             });
 
         if (fallback === undefined) {
-            throw new Error('Middleware: fallback route does not exist');
+            throw new Error('Routing: fallback route does not exist');
         }
 
         effect(() => {
-            let { parameters, route } = match(request, router, subdomain);
+            let { parameters, route } = match(request, router);
 
             state.parameters = parameters;
             state.route = route || fallback;
@@ -105,7 +103,7 @@ function middleware<T>(request: Request<T>, router: Router<T>) {
                 state.root = root;
 
                 return next(request);
-            }, scheduler);
+            });
         };
     };
 

package/src/constants.ts

@@ -1,3 +1,12 @@
+const ON_DELETE = ['DELETE'];
+
+const ON_GET = ['GET'];
+
+const ON_POST = ['POST'];
+
+const ON_PUT = ['PUT'];
+
+
 const PLACEHOLDER = 0;
 
 const STATIC = 1;
@@ -5,4 +14,4 @@ const STATIC = 1;
 const WILDCARD = 2;
 
 
-export { PLACEHOLDER, STATIC, WILDCARD };
+export { ON_DELETE, ON_GET, ON_POST, ON_PUT, PLACEHOLDER, STATIC, WILDCARD };

package/src/index.ts

@@ -1,8 +1,4 @@
-import browser from './browser';
-import router from './router';
-import { Router as R2 } from './router2';
-import slugify from './slugify';
-
-
-export { browser, router, slugify, R2 };
+export { default as browser } from './browser';
+export { default as router } from './router';
+export { default as slugify } from './slugify';
 export * from './types';

package/src/router/index.ts

@@ -1,10 +1,7 @@
-import { STATIC } from '~/constants';
-import { Options } from '~/types';
+import { ON_DELETE, ON_GET, ON_POST, ON_PUT, STATIC } from '~/constants';
+import { Name, Options, Request, Route, RouteOptions } from '~/types';
 import { Node } from './node';
-import { Route } from './route';
-
-
-let { isArray } = Array;
+import pipeline from '@esportsplus/pipeline';
 
 
 function normalize(path: string) {
@@ -12,7 +9,7 @@ function normalize(path: string) {
         path = '/' + path;
     }
 
-    if (path[path.length - 1] === '/') {
+    if (path.at(-1) === '/') {
         path = path.slice(0, -1);
     }
 
@@ -23,32 +20,31 @@ function radixkey(method: string, path: string, subdomain?: string | null) {
     return ((subdomain ? subdomain + ' ' : '') + method).toUpperCase() + ' ' + normalize(path);
 }
 
-function set<T>(route: Route<T>, key: keyof Route<T>, value?: unknown) {
-    if (!value) {
-        return;
-    }
+function set<T>(route: Route<T>, options: Options<T> | RouteOptions<T>) {
+    for (let key in options) {
+        let value = options[key as keyof typeof options] as any;
 
-    if (!route[key]) {
-        (route[key] as unknown) = value;
-    }
-    else if (typeof value === 'string') {
-        if (typeof route[key] === 'string') {
-            (route[key] as string) += value;
+        if (key === 'middleware') {
+            for (let i = 0, n = value.length; i < n; i++) {
+                route.pipeline.add(value[i]);
+            }
         }
-    }
-    else if (isArray(value)) {
-        if (isArray(route[key])) {
-            (route[key] as unknown[]).push( ...value );
+        else if (key === 'responder') {
+            route.pipeline.add(value);
+        }
+        else {
+            // @ts-ignore
+            route[key] = (route[key] || '') + value;
         }
     }
 }
 
 
 class Router<T> {
-    groups: Omit<Options<T>, 'responder'>[] = [];
+    groups: Options<T>[] = [];
     root: Node<T>;
-    routes: Record<string, Route<T>> = {};
-    static: Record<string, Route<T>> = {};
+    routes: Record<Name, Route<T>> = {};
+    static: Record<Name, Route<T>> = {};
     subdomains: string[] | null = null;
 
 
@@ -69,22 +65,20 @@ class Router<T> {
         return this;
     }
 
-    private route({ middleware, name, path, responder, subdomain }: Options<T>) {
-        let route = new Route(responder);
-
-        for (let i = 0, n = this.groups.length; i < n; i++) {
-            let { middleware, name, path, subdomain } = this.groups[i];
+    private route(options: RouteOptions<T>) {
+        let groups = this.groups,
+            route: Route<T> = {
+                name: null,
+                path: null,
+                pipeline: pipeline<Request<T>, T>(),
+                subdomain: null
+            };
 
-            set(route, 'name', name);
-            set(route, 'middleware', middleware);
-            set(route, 'path', path);
-            set(route, 'subdomain', subdomain);
+        for (let i = 0, n = groups.length; i < n; i++) {
+            set(route, groups[i]);
         }
 
-        set(route, 'name', name);
-        set(route, 'middleware', middleware);
-        set(route, 'path', path);
-        set(route, 'subdomain', subdomain);
+        set(route, options);
 
         if (route.path) {
             route.path = normalize(route.path);
@@ -98,15 +92,15 @@ class Router<T> {
     }
 
 
-    delete(options: Options<T>) {
-        return this.on(['DELETE'], options);
+    delete(options: RouteOptions<T>) {
+        return this.on(ON_DELETE, options);
     }
 
-    get(options: Options<T>) {
-        return this.on(['GET'], options);
+    get(options: RouteOptions<T>) {
+        return this.on(ON_GET, options);
     }
 
-    group(options: Router<T>['groups'][0]) {
+    group(options: Options<T>) {
         return {
             routes: (fn: (router: Router<T>) => void) => {
                 this.groups.push(options);
@@ -116,19 +110,19 @@ class Router<T> {
         }
     }
 
-    match(method: string, path: string, subdomain?: string | null): ReturnType<Node<T>['find']> {
+    match(method: string, path: string, subdomain?: string | null) {
         let key = radixkey(method, path, subdomain);
 
         if (key in this.static) {
             return {
-                route: this.static[key]
+                route: this.static[key] as Readonly<Route<T>>
             };
         }
 
         return this.root.find(key);
     }
 
-    on(methods: string[], options: Options<T>) {
+    on(methods: string[], options: RouteOptions<T>) {
         let route = this.route(options);
 
         if (route.name) {
@@ -169,15 +163,15 @@ class Router<T> {
         return this;
     }
 
-    post(options: Options<T>) {
-        return this.on(['POST'], options);
+    post(options: RouteOptions<T>) {
+        return this.on(ON_POST, options);
     }
 
-    put(options: Options<T>) {
-        return this.on(['PUT'], options);
+    put(options: RouteOptions<T>) {
+        return this.on(ON_PUT, options);
     }
 
-    uri(name: string, values: unknown[] = []) {
+    uri(name: Name, values: unknown[] = []) {
         let path = this.routes[name]?.path;
 
         if (!path) {
@@ -202,7 +196,9 @@ class Router<T> {
                 resolved.push(values[i]);
             }
             else if (symbol === '*') {
-                resolved.push( ...values.slice(i) );
+                for (let n = values.length; i < n; i++) {
+                    resolved.push( values[i] );
+                }
                 break;
             }
             else {

package/src/router/node.ts

@@ -60,8 +60,8 @@ class Node<T> {
     }
 
     find(path: string): {
-        parameters?: Record<PropertyKey, unknown>;
-        route?: Route<T>;
+        parameters?: Readonly<Record<PropertyKey, unknown>>;
+        route?: Readonly<Route<T>>;
     } {
         let node: Node<T> | undefined = this,
             parameters: Record<PropertyKey, unknown> = {},
@@ -96,7 +96,7 @@ class Node<T> {
             }
         }
 
-        if ((!node || !node.route) && wildcard) {
+        if ((node === undefined || node.route === null) && wildcard !== null) {
             node = wildcard.node;
             parameters[ node.property! ] = wildcard.value;
         }