@esportsplus/routing 0.0.4 → 0.0.6

package/build/group.js

@@ -2,7 +2,7 @@ export default () => {
     return {
         middleware: [],
         name: '',
-        pattern: '',
+        path: '',
         subdomain: ''
     };
 };

package/build/index.d.ts

@@ -8,9 +8,8 @@ declare const _default: {
         data: Record<string, any>;
         href: string;
         hostname: string;
-        uri: string;
         origin: string;
-        pathname: string;
+        path: string;
         port: string;
         protocol: string;
         query: {
@@ -24,9 +23,8 @@ declare const _default: {
                 data: Record<string, any>;
                 href: string;
                 hostname: string;
-                uri: string;
                 origin: string;
-                pathname: string;
+                path: string;
                 port: string;
                 protocol: string;
                 query: {
@@ -34,13 +32,12 @@ declare const _default: {
                 };
                 subdomain: string;
             }) => any;
-            match: (routes: import("./routes").Routes) => (request: {
+            match: ({ routes, subdomains }: import("./types").Routes) => (request: {
                 data: Record<string, any>;
                 href: string;
                 hostname: string;
-                uri: string;
                 origin: string;
-                pathname: string;
+                path: string;
                 port: string;
                 protocol: string;
                 query: {
@@ -53,9 +50,8 @@ declare const _default: {
             data: Record<string, any>;
             href: string;
             hostname: string;
-            uri: string;
             origin: string;
-            pathname: string;
+            path: string;
             port: string;
             protocol: string;
             query: {
@@ -65,15 +61,23 @@ declare const _default: {
         }) => Promise<unknown>;
     };
     redirect: (key: string, _?: Record<string, any>) => void;
-    routes: import("./routes").Routes;
+    routes: {
+        add: ({ name, path, responder }: {
+            name: string;
+            path?: string | undefined;
+            responder: import("./types").Responder;
+        }) => import("./types").Route;
+        group: (group: any, fn: (routes: import("./types").Routes) => void) => void;
+        routes: Record<string, import("./types").Route>;
+        subdomains: Record<string, Record<string, string>>;
+    };
     url: {
         parse: (url?: string) => {
             data: Record<string, any>;
             href: string;
             hostname: string;
-            uri: string;
             origin: string;
-            pathname: string;
+            path: string;
             port: string;
             protocol: string;
             query: {

package/build/middleware/common/index.d.ts

@@ -3,9 +3,8 @@ declare const _default: {
         data: Record<string, any>;
         href: string;
         hostname: string;
-        uri: string;
         origin: string;
-        pathname: string;
+        path: string;
         port: string;
         protocol: string;
         query: {
@@ -13,13 +12,12 @@ declare const _default: {
         };
         subdomain: string;
     }) => any;
-    match: (routes: import("../../routes").Routes) => (request: {
+    match: ({ routes, subdomains }: import("../../types").Routes) => (request: {
         data: Record<string, any>;
         href: string;
         hostname: string;
-        uri: string;
         origin: string;
-        pathname: string;
+        path: string;
         port: string;
         protocol: string;
         query: {

package/build/middleware/common/match.d.ts

@@ -1,4 +1,3 @@
-import { Routes } from '../../routes';
-import { Next, Request } from '../../types';
-declare const _default: (routes: Routes) => (request: Request, next: Next) => unknown;
+import { Next, Request, Routes } from '../../types';
+declare const _default: ({ routes, subdomains }: Routes) => (request: Request, next: Next) => unknown;
 export default _default;

package/build/middleware/common/match.js

@@ -1,10 +1,10 @@
-export default (routes) => {
+export default ({ routes, subdomains }) => {
     return (request, next) => {
-        let name = (routes.subdomains[request.subdomain] || {})[request.uri], route = routes.static[name];
+        let name = (subdomains[request.subdomain] || {})[request.path], route = routes[name];
         if (!route) {
         }
         if (!route && routes.fallback) {
-            route = routes.static[routes.fallback];
+            route = routes.fallback;
         }
         request.data.route = route;
         return next(request);

package/build/middleware/index.d.ts

@@ -6,9 +6,8 @@ declare const _default: {
             data: Record<string, any>;
             href: string;
             hostname: string;
-            uri: string;
             origin: string;
-            pathname: string;
+            path: string;
             port: string;
             protocol: string;
             query: {
@@ -16,13 +15,12 @@ declare const _default: {
             };
             subdomain: string;
         }) => any;
-        match: (routes: import("../routes").Routes) => (request: {
+        match: ({ routes, subdomains }: import("../types").Routes) => (request: {
             data: Record<string, any>;
             href: string;
             hostname: string;
-            uri: string;
             origin: string;
-            pathname: string;
+            path: string;
             port: string;
             protocol: string;
             query: {
@@ -35,9 +33,8 @@ declare const _default: {
         data: Record<string, any>;
         href: string;
         hostname: string;
-        uri: string;
         origin: string;
-        pathname: string;
+        path: string;
         port: string;
         protocol: string;
         query: {

package/build/redirect.js

@@ -1,10 +1,10 @@
-import routes from './routes';
+import { routes } from './routes';
 export default (key, _ = {}) => {
     if (key.startsWith('http://') || key.startsWith('https://')) {
         window.location.replace(key);
     }
-    if (!routes.static[key]) {
+    if (!routes[key]) {
         throw new Error(`Route '${key}' does not exist`);
     }
-    window.location.hash = `#${routes.static[key].pattern}`;
+    window.location.hash = `#${routes[key].path || ''}`;
 };

package/build/routes.d.ts

@@ -1,13 +1,20 @@
-import { Group, Responder, Route } from './types';
-declare class Routes {
-    dynamic: Record<Route['name'], Route>;
-    fallback?: string;
-    groups: Group[];
-    static: Record<Route['name'], Route>;
-    subdomains: Record<Route['subdomain'], Record<Route['pattern'], Route['name']>>;
-    add(name: string, pattern: string, responder: Responder): Route;
-    group(group: any, routes: (routes: Routes) => void): void;
-}
-declare const _default: Routes;
+import { Responder, Routes, Route } from './types';
+declare let routes: Record<Route['name'], Route>, subdomains: Record<NonNullable<Route['subdomain']>, Record<NonNullable<Route['path']>, Route['name']>>;
+declare const add: ({ name, path, responder }: {
+    name: string;
+    path?: string | undefined;
+    responder: Responder;
+}) => Route;
+declare const group: (group: any, fn: (routes: Routes) => void) => void;
+declare const _default: {
+    add: ({ name, path, responder }: {
+        name: string;
+        path?: string | undefined;
+        responder: Responder;
+    }) => Route;
+    group: (group: any, fn: (routes: Routes) => void) => void;
+    routes: Record<string, Route>;
+    subdomains: Record<string, Record<string, string>>;
+};
 export default _default;
-export { Routes };
+export { add, group, routes, subdomains };

package/build/routes.js

@@ -1,46 +1,45 @@
-class Routes {
-    dynamic = {};
-    fallback;
-    groups = [];
-    static = {};
-    subdomains = {};
-    add(name, pattern, responder) {
-        let route = {
-            middleware: [],
-            name: '',
-            pattern: '',
-            responder,
-            subdomain: ''
-        };
-        for (let i = 0, n = this.groups.length; i < n; i++) {
-            let group = this.groups[i];
-            route.name += group.name;
-            route.pattern += group.pattern;
+let groups = [], routes = {}, subdomains = {};
+const add = ({ name, path, responder }) => {
+    let http = path !== undefined, route = {
+        middleware: [],
+        name: '',
+        responder
+    };
+    if (http) {
+        route.path = '';
+        route.subdomain = '';
+    }
+    for (let i = 0, n = groups.length; i < n; i++) {
+        let group = groups[i];
+        if (group.middleware.length) {
+            route.middleware.push(...group.middleware);
+        }
+        route.name += group.name;
+        if (http) {
+            route.path += group.path;
             route.subdomain = group.subdomain + route.subdomain;
-            if (group.middleware.length) {
-                route.middleware.push(...group.middleware);
-            }
         }
-        route.name += name;
-        route.pattern += pattern;
-        if (route.pattern[0] !== '/') {
-            route.pattern = `/${route.pattern}`;
+    }
+    routes[route.name += name] = route;
+    if (http) {
+        route.path = `${route.path}${path}`;
+        if (route.path[0] !== '/') {
+            route.path = `/${route.path}`;
         }
-        if (route.subdomain === 'www') {
+        if (!route.subdomain || route.subdomain === 'www') {
             route.subdomain = '';
         }
-        if (!this.subdomains[route.subdomain]) {
-            this.subdomains[route.subdomain] = {};
+        if (!subdomains[route.subdomain]) {
+            subdomains[route.subdomain] = {};
         }
-        this.static[route.name] = route;
-        this.subdomains[route.subdomain][route.pattern] = route.name;
-        return route;
-    }
-    group(group, routes) {
-        this.groups.push(group);
-        routes(this);
-        this.groups.pop();
+        subdomains[route.subdomain][route.path] = route.name;
     }
-}
-export default new Routes();
-export { Routes };
+    return route;
+};
+const group = (group, fn) => {
+    groups.push(group);
+    fn({ add, group, routes, subdomains });
+    groups.pop();
+};
+export default { add, group, routes, subdomains };
+export { add, group, routes, subdomains };

package/build/types.d.ts

@@ -1,20 +1,26 @@
-import { Routes } from './routes';
 import { parse } from './url';
+import routes from './routes';
 type Group = {
     middleware: Middleware[];
     name: string;
-    pattern: string;
+    path: string;
     subdomain: string;
 };
 type Middleware = (request: Request, next: Next) => unknown;
 type Next = (request: Request) => unknown;
 type Request = ReturnType<typeof parse>;
 type Responder = (request: Request) => Promise<unknown> | unknown;
+type Routes = {
+    add: typeof routes.add;
+    group: typeof routes.group;
+    routes: typeof routes.routes;
+    subdomains: typeof routes.subdomains;
+};
 type Route = {
     middleware: Middleware[];
     name: string;
-    pattern: string;
+    path?: string;
     responder: Responder;
-    subdomain: string;
+    subdomain?: string;
 };
 export { Group, Middleware, Next, Request, Responder, Route, Routes };

package/build/types.js

@@ -1,2 +1 @@
-import { Routes } from './routes';
-export { Routes };
+export {};

package/build/url.d.ts

@@ -2,9 +2,8 @@ declare const parse: (url?: string) => {
     data: Record<string, any>;
     href: string;
     hostname: string;
-    uri: string;
     origin: string;
-    pathname: string;
+    path: string;
     port: string;
     protocol: string;
     query: {
@@ -17,9 +16,8 @@ declare const _default: {
         data: Record<string, any>;
         href: string;
         hostname: string;
-        uri: string;
         origin: string;
-        pathname: string;
+        path: string;
         port: string;
         protocol: string;
         query: {

package/build/url.js

@@ -1,5 +1,5 @@
-const parse = (url = window.location.href) => {
-    let data = new URL(url), parts = data.host.split('.'), subdomain = '';
+const parse = (url = window?.location?.href || '') => {
+    let { hash, host, hostname, href, origin, port, protocol } = new URL(url), parts = host.split('.'), path = hash?.replace('#/', '/')?.split('?') || ['/', ''], subdomain = '';
     if (parts.length > 2) {
         subdomain = parts[0];
         if (['127', 'www'].includes(subdomain)) {
@@ -8,14 +8,13 @@ const parse = (url = window.location.href) => {
     }
     return {
         data: {},
-        href: data.href,
-        hostname: data.hostname,
-        uri: data.hash.replace('#/', '/') || '/',
-        origin: data.origin,
-        pathname: data.pathname,
-        port: data.port,
-        protocol: data.protocol,
-        query: Object.fromEntries(data.searchParams.entries()),
+        href: href,
+        hostname: hostname,
+        origin: origin,
+        path: path[0],
+        port: port,
+        protocol: protocol,
+        query: Object.fromEntries((new URLSearchParams(path[1])).entries()),
         subdomain
     };
 };

package/package.json

@@ -2,8 +2,8 @@
     "author": "ICJR",
     "description": "Routing",
     "devDependencies": {
-        "tsc-alias": "^1.8.1",
-        "typescript": "^4.9.3"
+        "tsc-alias": "^1.8.2",
+        "typescript": "^4.9.4"
     },
     "main": "./build/index.js",
     "name": "@esportsplus/routing",
@@ -15,12 +15,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "./build/index.d.ts",
-    "typesVersions": {
-        "*": {
-            "types": [
-                "build/types"
-            ]
-        }
-    },
-    "version": "0.0.4"
+    "version": "0.0.6"
 }

package/src/group.ts

@@ -1,11 +1,11 @@
-import { Group } from "./types";
-
-
-export default (): Group => {
-    return {
-        middleware: [],
-        name: '',
-        pattern: '',
-        subdomain: ''
-    };
-};
+import { Group } from "./types";
+
+
+export default (): Group => {
+    return {
+        middleware: [],
+        name: '',
+        path: '',
+        subdomain: ''
+    };
+};

package/src/index.ts

@@ -1,9 +1,9 @@
-import middleware from './middleware';
-import redirect from './redirect';
-import listener from './listener';
-import routes from './routes';
-import url from './url';
-
-
-export default { listener, middleware, redirect, routes, url };
-export { listener, middleware, redirect, routes, url };
+import middleware from './middleware';
+import redirect from './redirect';
+import listener from './listener';
+import routes from './routes';
+import url from './url';
+
+
+export default { listener, middleware, redirect, routes, url };
+export { listener, middleware, redirect, routes, url };

package/src/middleware/common/dispatch.ts

@@ -1,17 +1,17 @@
-import { factory } from '~/middleware';
-import { Request } from '~/types';
-
-
-export default (request: Request) => {
-    let route = request.data.route;
-
-    if (!route) {
-        throw new Error(`Route dispatching failed, route was not defined!`);
-    }
-
-    if (!route.middleware.length) {
-        return route.responder(request);
-    }
-
-    return factory(...route.middleware, (request => route.responder(request)))(request);
-};
+import { factory } from '~/middleware';
+import { Request } from '~/types';
+
+
+export default (request: Request) => {
+    let route = request.data.route;
+
+    if (!route) {
+        throw new Error(`Route dispatching failed, route was not defined!`);
+    }
+
+    if (!route.middleware.length) {
+        return route.responder(request);
+    }
+
+    return factory(...route.middleware, (request => route.responder(request)))(request);
+};

package/src/middleware/common/index.ts

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

package/src/middleware/common/match.ts

@@ -1,26 +1,24 @@
-import { Routes } from '~/routes';
-import { Next, Request } from '~/types';
-
-
-export default (routes: Routes) => {
-    return (request: Request, next: Next) => {
-        let name = (routes.subdomains[request.subdomain] || {})[request.uri],
-            route = routes.static[name];
-
-        // Dynamic routing
-        if (!route) {
-            // TODO:
-            // - Trie based routing
-            // - Bind variables to request
-        }
-
-        // Fallback route
-        if (!route && routes.fallback) {
-            route = routes.static[routes.fallback];
-        }
-
-        request.data.route = route;
-
-        return next(request);
-    };
-};
+import { Next, Request, Routes } from '~/types';
+
+
+export default ({ routes, subdomains }: Routes) => {
+    return (request: Request, next: Next) => {
+        let name = (subdomains[request.subdomain] || {})[request.path],
+            route = routes[name];
+
+        // Dynamic routing
+        if (!route) {
+            // TODO:
+            // - Trie based routing
+            // - Bind variables to request
+        }
+
+        if (!route && routes.fallback) {
+            route = routes.fallback;
+        }
+
+        request.data.route = route;
+
+        return next(request);
+    };
+};

package/src/redirect.ts

@@ -1,4 +1,4 @@
-import routes from './routes';
+import { routes } from './routes';
 
 
 export default (key: string, _: Record<string, any> = {}) => {
@@ -8,9 +8,9 @@ export default (key: string, _: Record<string, any> = {}) => {
     }
 
     // Internal route based redirect
-    if (!routes.static[key]) {
+    if (!routes[key]) {
         throw new Error(`Route '${key}' does not exist`);
     }
 
-    window.location.hash = `#${routes.static[key].pattern}`;
+    window.location.hash = `#${routes[key].path || ''}`;
 };

package/src/routes.ts

@@ -1,63 +1,68 @@
-import { Group, Responder, Route } from './types';
-
-
-class Routes {
-    dynamic: Record<Route['name'], Route> = {};
-    fallback?: string;
-    groups: Group[] = [];
-    static: Record<Route['name'], Route> = {};
-    subdomains: Record<Route['subdomain'], Record<Route['pattern'], Route['name']>> = {};
-
-
-    add(name: string, pattern: string, responder: Responder) {
-        let route: Route = {
-                middleware: [],
-                name: '',
-                pattern: '',
-                responder,
-                subdomain: ''
-            };
-
-        for (let i = 0, n = this.groups.length; i < n; i++) {
-            let group = this.groups[i];
-
-            route.name += group.name;
-            route.pattern += group.pattern;
-            route.subdomain = group.subdomain + route.subdomain;
-
-            if (group.middleware.length) {
-                route.middleware.push(...group.middleware);
-            }
-        }
-
-        route.name += name;
-        route.pattern += pattern;
-
-        if (route.pattern[0] !== '/') {
-            route.pattern = `/${route.pattern}`;
-        }
-
-        if (route.subdomain === 'www') {
-            route.subdomain = '';
-        }
-
-        if (!this.subdomains[route.subdomain]) {
-            this.subdomains[route.subdomain] = {};
-        }
-
-        this.static[route.name] = route;
-        this.subdomains[route.subdomain][route.pattern] = route.name;
-
-        return route;
-    }
-
-    group(group: any, routes: (routes: Routes) => void) {
-        this.groups.push(group);
-        routes(this);
-        this.groups.pop();
-    }
-}
-
-
-export default new Routes();
-export { Routes };
+import { Group, Responder, Routes, Route } from './types';
+
+
+let groups: Group[] = [],
+    routes: Record<Route['name'], Route> = {},
+    subdomains: Record<NonNullable<Route['subdomain']>, Record<NonNullable<Route['path']>, Route['name']>> = {};
+
+
+const add = ({ name, path, responder }: { name: string, path?: string, responder: Responder }) => {
+    let http = path !== undefined,
+        route: Route = {
+            middleware: [],
+            name: '',
+            responder
+        };
+
+    if (http) {
+        route.path = '';
+        route.subdomain = '';
+    }
+
+    for (let i = 0, n = groups.length; i < n; i++) {
+        let group = groups[i];
+
+        if (group.middleware.length) {
+            route.middleware.push(...group.middleware);
+        }
+
+        route.name += group.name;
+
+        if (http) {
+            route.path += group.path;
+            route.subdomain = group.subdomain + route.subdomain;
+        }
+    }
+
+    routes[ route.name += name ] = route;
+
+    if (http) {
+        route.path = `${route.path}${path}`;
+
+        if (route.path[0] !== '/') {
+            route.path = `/${route.path}`;
+        }
+
+        if (!route.subdomain || route.subdomain === 'www') {
+            route.subdomain = '';
+        }
+
+        if (!subdomains[route.subdomain]) {
+            subdomains[route.subdomain] = {};
+        }
+
+        subdomains[route.subdomain][route.path] = route.name;
+    }
+
+    return route;
+};
+
+const group = (group: any, fn: (routes: Routes) => void) => {
+    groups.push(group);
+    fn({ add, group, routes, subdomains });
+    groups.pop();
+};
+
+
+export default { add, group, routes, subdomains };
+export { add, group, routes, subdomains };

package/src/types.ts

@@ -1,11 +1,11 @@
-import { Routes } from './routes';
 import { parse } from './url';
+import routes from './routes';
 
 
 type Group = {
     middleware: Middleware[];
     name: string;
-    pattern: string;
+    path: string;
     subdomain: string;
 };
 
@@ -17,12 +17,19 @@ type Request = ReturnType<typeof parse>;
 
 type Responder = (request: Request) => Promise<unknown> | unknown;
 
+type Routes = {
+    add: typeof routes.add;
+    group: typeof routes.group;
+    routes: typeof routes.routes;
+    subdomains: typeof routes.subdomains;
+};
+
 type Route = {
     middleware: Middleware[];
     name: string;
-    pattern: string;
+    path?: string;
     responder: Responder;
-    subdomain: string;
+    subdomain?: string;
 };
 
 

package/src/url.ts

@@ -1,6 +1,7 @@
-const parse = (url: string = window.location.href) => {
-    let data = new URL( url ),
-        parts = data.host.split('.'),
+const parse = (url: string = window?.location?.href || '') => {
+    let { hash, host, hostname, href, origin, port, protocol } = new URL( url ),
+        parts = host.split('.'),
+        path = hash?.replace('#/', '/')?.split('?') || ['/', ''],
         subdomain = '';
 
     if (parts.length > 2) {
@@ -13,14 +14,13 @@ const parse = (url: string = window.location.href) => {
 
     return {
         data: {} as Record<string, any>,
-        href: data.href,
-        hostname: data.hostname,
-        uri: data.hash.replace('#/', '/') || '/',
-        origin: data.origin,
-        pathname: data.pathname,
-        port: data.port,
-        protocol: data.protocol,
-        query: Object.fromEntries( data.searchParams.entries() ),
+        href: href,
+        hostname: hostname,
+        origin: origin,
+        path: path[0],
+        port: port,
+        protocol: protocol,
+        query: Object.fromEntries( (new URLSearchParams(path[1])).entries() ),
         subdomain
     };
 };

package/build/middleware/dispatch.d.ts

@@ -1,3 +0,0 @@
-import { Request } from '../types';
-declare const _default: (request: Request) => any;
-export default _default;

package/build/middleware/dispatch.js

@@ -1,11 +0,0 @@
-import { middleware } from '../request';
-export default (request) => {
-    let route = request.data.route;
-    if (!route) {
-        throw new Error(`Route dispatching failed, route was not defined!`);
-    }
-    if (!route.middleware.length) {
-        return route.responder(request);
-    }
-    return middleware(...route.middleware, (request => route.responder(request)))(request);
-};

package/build/middleware/match.d.ts

@@ -1,4 +0,0 @@
-import { Routes } from '../routes';
-import { Next, Request } from '../types';
-declare const _default: (routes: Routes) => (request: Request, next: Next) => unknown;
-export default _default;

package/build/middleware/match.js

@@ -1,12 +0,0 @@
-export default (routes) => {
-    return (request, next) => {
-        let name = (routes.subdomains[request.subdomain] || {})[request.uri], route = routes.static[name];
-        if (!route) {
-        }
-        if (!route && routes.fallback) {
-            route = routes.static[routes.fallback];
-        }
-        request.data.route = route;
-        return next(request);
-    };
-};

package/build/request/index.d.ts

@@ -1,34 +0,0 @@
-import middleware from './middleware';
-import parse from './parse';
-declare const _default: {
-    middleware: (...middleware: import("./types").Middleware[]) => (request: {
-        data: Record<string, any>;
-        href: string;
-        hostname: string;
-        uri: string;
-        origin: string;
-        pathname: string;
-        port: string;
-        protocol: string;
-        query: {
-            [k: string]: string;
-        };
-        subdomain: string;
-    }) => Promise<unknown>;
-    parse: (url?: string) => {
-        data: Record<string, any>;
-        href: string;
-        hostname: string;
-        uri: string;
-        origin: string;
-        pathname: string;
-        port: string;
-        protocol: string;
-        query: {
-            [k: string]: string;
-        };
-        subdomain: string;
-    };
-};
-export default _default;
-export { middleware, parse };

package/build/request/index.js

@@ -1,4 +0,0 @@
-import middleware from './middleware';
-import parse from './parse';
-export default { middleware, parse };
-export { middleware, parse };

package/build/request/middleware.d.ts

@@ -1,3 +0,0 @@
-import { Middleware, Request } from './types';
-declare const _default: (...middleware: Middleware[]) => (request: Request) => Promise<unknown>;
-export default _default;

package/build/request/middleware.js

@@ -1,12 +0,0 @@
-export default (...middleware) => {
-    let i = -1, n = middleware.length, next = (request) => middleware[++i](request, (i < n ? next : () => {
-        throw new Error('Request middleware did not return a responder');
-    }));
-    return async (request) => {
-        if (!middleware.length) {
-            throw new Error('Request middleware has not been defined');
-        }
-        i = -1;
-        return await next(request);
-    };
-};

package/build/request/parse.d.ts

@@ -1,15 +0,0 @@
-declare const _default: (url?: string) => {
-    data: Record<string, any>;
-    href: string;
-    hostname: string;
-    uri: string;
-    origin: string;
-    pathname: string;
-    port: string;
-    protocol: string;
-    query: {
-        [k: string]: string;
-    };
-    subdomain: string;
-};
-export default _default;

package/build/request/parse.js

@@ -1,18 +0,0 @@
-export default (url = window.location.href) => {
-    let data = new URL(url), subdomain = data.host.split('.')[0] || '';
-    if (['127', 'www'].includes(`${subdomain}`)) {
-        subdomain = '';
-    }
-    return {
-        data: {},
-        href: data.href,
-        hostname: data.hostname,
-        uri: data.hash.replace('#/', '/') || '/',
-        origin: data.origin,
-        pathname: data.pathname,
-        port: data.port,
-        protocol: data.protocol,
-        query: Object.fromEntries(data.searchParams.entries()),
-        subdomain
-    };
-};

package/build/request/types.d.ts

@@ -1,6 +0,0 @@
-import parse from './parse';
-type Middleware = (request: Request, next: Next) => unknown;
-type Next = (request: Request) => unknown;
-type Request = ReturnType<typeof parse>;
-type Responder = (request: Request) => Promise<unknown> | unknown;
-export { Middleware, Next, Request, Responder };

package/build/request/types.js

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