@esportsplus/routing 0.0.10 → 0.0.11

package/build/middleware/index.d.ts

@@ -1,24 +1,17 @@
+import factory from '@esportsplus/middleware';
 import dispatch from './dispatch';
-import factory from './factory';
 import match from './match';
 declare const _default: {
     dispatch: (request: {
         data: {
             parameters?: Record<PropertyKey, unknown> | undefined;
-            route?: import("../router").Route | undefined;
+            route?: import("../router/route").Route | undefined;
         };
     }) => unknown;
-    factory: (...middleware: import("../types").Middleware[]) => <T>(request: T) => unknown;
-    match: (router: import("../router").Router, spa?: boolean) => (request: {
-        data: {
-            parameters?: Record<PropertyKey, unknown> | undefined;
-            route?: import("../router").Route | undefined;
-        };
-        hostname: string;
-        method: string;
-        path: string;
-        subdomain?: string | undefined;
-    }, next: import("../types").Next) => unknown;
+    factory: <I, R>(...middleware: import("@esportsplus/middleware/build/types").Middleware<I, R>[]) => import("@esportsplus/middleware/build/types").Next<I, R>;
+    match: (router: import("../router").Router, { spa }?: {
+        spa?: boolean | undefined;
+    }) => (request: import("../types").Request, next: import("@esportsplus/middleware/build/types").Next<import("../types").Request, unknown>) => unknown;
 };
 export default _default;
 export { dispatch, factory, match };

package/build/middleware/index.js

@@ -1,5 +1,5 @@
+import factory from '@esportsplus/middleware';
 import dispatch from './dispatch';
-import factory from './factory';
 import match from './match';
 export default { dispatch, factory, match };
 export { dispatch, factory, match };

package/build/middleware/match.d.ts

@@ -1,10 +1,5 @@
-import { Next, Router } from '../types';
-type Request = {
-    data: ReturnType<Router['match']>;
-    hostname: string;
-    method: string;
-    path: string;
-    subdomain?: string;
-};
-declare const _default: (router: Router, spa?: boolean) => (request: Request, next: Next) => unknown;
+import { Next, Request, Router } from '../types';
+declare const _default: (router: Router, { spa }?: {
+    spa?: boolean | undefined;
+}) => (request: Request, next: Next<Request, unknown>) => unknown;
 export default _default;

package/build/middleware/match.js

@@ -1,4 +1,4 @@
-export default (router, spa = false) => {
+export default (router, { spa } = {}) => {
     let subdomain = null;
     return (request, next) => {
         if ((typeof request.subdomain !== 'string' && !spa) || subdomain === null) {

package/build/router/index.d.ts

@@ -1,16 +1,6 @@
-import { Middleware, Responder, Options } from '../types';
+import { Options } from '../types';
 import { Node } from './node';
-import factory from '../middleware/factory';
-declare class Route {
-    dispatch: ReturnType<typeof factory> | null;
-    name: string | null;
-    path: string | null;
-    responder: Responder;
-    stack: Middleware[] | null;
-    subdomain: string | null;
-    constructor(responder: Responder);
-    get dispatcher(): <T>(request: T) => unknown;
-}
+import { Route } from './route';
 declare class Router {
     groups: Omit<Options, 'responder'>[];
     root: Node;

package/build/router/index.js

@@ -1,7 +1,7 @@
 import { STATIC } from "../symbols";
 import { Node } from './node';
 import { normalize, radixkey } from './path';
-import factory from '../middleware/factory';
+import { Route } from './route';
 let { isArray } = Array;
 function set(route, key, value) {
     if (!value) {
@@ -21,28 +21,6 @@ function set(route, key, value) {
         }
     }
 }
-class Route {
-    dispatch = null;
-    name = null;
-    path = null;
-    responder;
-    stack = null;
-    subdomain = null;
-    constructor(responder) {
-        this.responder = responder;
-    }
-    get dispatcher() {
-        if (this.dispatch === null) {
-            if (!this.stack?.length) {
-                this.dispatch = (request) => this.responder(request);
-            }
-            else {
-                this.dispatch = factory(...this.stack, (request => this.responder(request)));
-            }
-        }
-        return this.dispatch;
-    }
-}
 class Router {
     groups = [];
     root;
@@ -178,5 +156,5 @@ class Router {
         return resolved.join('/');
     }
 }
-export default (...args) => new Router(...args);
+export default () => new Router();
 export { Router, Route };

package/build/router/path.d.ts

@@ -3,12 +3,4 @@ declare const radixkey: (path: string, { method, subdomain }?: {
     method?: string | null | undefined;
     subdomain?: string | null | undefined;
 }) => string;
-declare const _default: {
-    normalize: (path: string) => string;
-    radixkey: (path: string, { method, subdomain }?: {
-        method?: string | null | undefined;
-        subdomain?: string | null | undefined;
-    }) => string;
-};
-export default _default;
 export { normalize, radixkey };

package/build/router/path.js

@@ -1,6 +1,6 @@
 const normalize = (path) => {
     if (path[0] !== '/') {
-        path = `/${path}`;
+        path = '/' + path;
     }
     if (path.endsWith('/')) {
         path = path.slice(0, -1);
@@ -17,5 +17,4 @@ const radixkey = (path, { method, subdomain } = {}) => {
     }
     return prefix.toUpperCase() + normalize(path);
 };
-export default { normalize, radixkey };
 export { normalize, radixkey };

package/build/router/route.d.ts

@@ -0,0 +1,13 @@
+import { Middleware, Responder } from '../types';
+import { factory } from '../middleware';
+declare class Route {
+    dispatch: ReturnType<typeof factory> | null;
+    name: string | null;
+    path: string | null;
+    responder: Responder;
+    stack: Middleware<unknown, unknown>[] | null;
+    subdomain: string | null;
+    constructor(responder: Responder);
+    get dispatcher(): import("@esportsplus/middleware/build/types").Next<unknown, unknown>;
+}
+export { Route };

package/build/router/route.js

@@ -0,0 +1,24 @@
+import { factory } from '../middleware';
+class Route {
+    dispatch = null;
+    name = null;
+    path = null;
+    responder;
+    stack = null;
+    subdomain = null;
+    constructor(responder) {
+        this.responder = responder;
+    }
+    get dispatcher() {
+        if (this.dispatch === null) {
+            if (!this.stack?.length) {
+                this.dispatch = (request) => this.responder(request);
+            }
+            else {
+                this.dispatch = factory(...this.stack, (request => this.responder(request)));
+            }
+        }
+        return this.dispatch;
+    }
+}
+export { Route };

package/build/types.d.ts

@@ -1,12 +1,18 @@
+import { Middleware, Next } from '@esportsplus/middleware';
 import { Route, Router } from './router';
-type Middleware = <T>(request: T, next: Next) => unknown;
-type Next = <T>(request: T) => unknown;
 type Options = {
-    middleware?: Middleware[];
+    middleware?: Middleware<Request, unknown>[];
     name?: string;
     path?: string;
     responder: Responder;
     subdomain?: string;
 };
+type Request = {
+    data: ReturnType<Router['match']>;
+    hostname: string;
+    method: string;
+    path: string;
+    subdomain?: string;
+};
 type Responder = <T>(request: T) => Promise<unknown> | unknown;
-export { Middleware, Next, Options, Responder, Route, Router };
+export { Middleware, Next, Options, Request, Responder, Route, Router };

package/package.json

@@ -1,6 +1,5 @@
 {
     "author": "ICJR",
-    "description": "Routing",
     "devDependencies": {
         "@esportsplus/rspack": "^0.0.15"
     },
@@ -14,5 +13,8 @@
         "prepublishOnly": "npm run build"
     },
     "types": "./build/index.d.ts",
-    "version": "0.0.10"
+    "version": "0.0.11",
+    "dependencies": {
+        "@esportsplus/middleware": "^0.0.4"
+    }
 }

package/src/middleware/index.ts

@@ -1,5 +1,5 @@
+import factory from '@esportsplus/middleware';
 import dispatch from './dispatch';
-import factory from './factory';
 import match from './match';
 
 

package/src/middleware/match.ts

@@ -1,19 +1,10 @@
-import { Next, Router } from '~/types';
+import { Next, Request, Router } from '~/types';
 
 
-type Request = {
-    data: ReturnType<Router['match']>;
-    hostname: string;
-    method: string;
-    path: string;
-    subdomain?: string;
-};
-
-
-export default (router: Router, spa = false) => {
+export default (router: Router, { spa }: { spa?: boolean } = {}) => {
     let subdomain: string | null = null;
 
-    return (request: Request, next: Next) => {
+    return (request: Request, next: Next<Request, unknown>) => {
         if ((typeof request.subdomain !== 'string' && !spa) || subdomain === null) {
             if (router.subdomains) {
                 for (let i = 0, n = router.subdomains.length; i < n; i++) {

package/src/router/index.ts

@@ -1,8 +1,8 @@
 import { STATIC } from "~/symbols";
-import { Middleware, Responder, Options } from '~/types';
+import { Options } from '~/types';
 import { Node } from './node';
 import { normalize, radixkey } from './path';
-import factory from '~/middleware/factory';
+import { Route } from './route';
 
 
 let { isArray } = Array;
@@ -29,34 +29,6 @@ function set(route: Route, key: keyof Route, value?: any) {
 }
 
 
-class Route {
-    dispatch: ReturnType<typeof factory> | null = null;
-    name: string | null = null;
-    path: string | null = null;
-    responder: Responder;
-    stack: Middleware[] | null = null;
-    subdomain: string | null = null;
-
-
-    constructor(responder: Responder) {
-        this.responder = responder;
-    }
-
-
-    get dispatcher() {
-        if (this.dispatch === null) {
-            if (!this.stack?.length) {
-                this.dispatch = <T>(request: T) => this.responder(request);
-            }
-            else {
-                this.dispatch = factory(...this.stack, (request => this.responder(request)));
-            }
-        }
-
-        return this.dispatch;
-    }
-}
-
 class Router {
     groups: Omit<Options, 'responder'>[] = [];
     root: Node;
@@ -233,5 +205,5 @@ class Router {
 }
 
 
-export default (...args: ConstructorParameters<typeof Router>) => new Router(...args);
+export default () => new Router();
 export { Router, Route };

package/src/router/path.ts

@@ -1,6 +1,6 @@
 const normalize = (path: string) => {
     if (path[0] !== '/') {
-        path = `/${path}`;
+        path = '/' + path;
     }
 
     if (path.endsWith('/')) {
@@ -25,5 +25,4 @@ const radixkey = (path: string, { method, subdomain }: { method?: string | null;
 };
 
 
-export default { normalize, radixkey };
 export { normalize, radixkey };

package/src/router/route.ts

@@ -0,0 +1,34 @@
+import { Middleware, Responder } from '~/types';
+import { factory } from '~/middleware';
+
+
+class Route {
+    dispatch: ReturnType<typeof factory> | null = null;
+    name: string | null = null;
+    path: string | null = null;
+    responder: Responder;
+    stack: Middleware<unknown, unknown>[] | null = null;
+    subdomain: string | null = null;
+
+
+    constructor(responder: Responder) {
+        this.responder = responder;
+    }
+
+
+    get dispatcher() {
+        if (this.dispatch === null) {
+            if (!this.stack?.length) {
+                this.dispatch = <T>(request: T) => this.responder(request);
+            }
+            else {
+                this.dispatch = factory(...this.stack, (request => this.responder(request)));
+            }
+        }
+
+        return this.dispatch;
+    }
+}
+
+
+export { Route };

package/src/types.ts

@@ -1,19 +1,24 @@
+import { Middleware, Next } from '@esportsplus/middleware';
 import { Route, Router } from './router';
 
 
-type Middleware = <T>(request: T, next: Next) => unknown;
-
-type Next = <T>(request: T) => unknown;
-
 type Options = {
-    middleware?: Middleware[];
+    middleware?: Middleware<Request, unknown>[];
     name?: string;
     path?: string;
     responder: Responder;
     subdomain?: string;
 };
 
+type Request = {
+    data: ReturnType<Router['match']>;
+    hostname: string;
+    method: string;
+    path: string;
+    subdomain?: string;
+};
+
 type Responder = <T>(request: T) => Promise<unknown> | unknown;
 
 
-export { Middleware, Next, Options, Responder, Route, Router };
+export { Middleware, Next, Options, Request, Responder, Route, Router };

package/src/middleware/factory.ts

@@ -1,22 +0,0 @@
-import { Middleware, Next } from '~/types';
-
-
-function error() {
-    throw new Error('Routing: request middleware did not return a responder');
-}
-
-
-// TODO: Use '@esportsplus/middleware'
-export default (...middleware: Middleware[]) => {
-    let stack: Next[] = [];
-
-    for (let i = 0, n = middleware.length; i < n; i++) {
-        stack[i] = <T>(request: T) => middleware[i](request, stack[i + 1] || error);
-    }
-
-    if (!stack.length) {
-        throw new Error('Routing: request middleware has not been defined');
-    }
-
-    return <T>(request: T) => stack[0](request);
-};