@esportsplus/routing 0.0.13 → 0.0.14

package/build/index.d.ts

@@ -1,6 +1,6 @@
-import spa from './spa';
 import middleware from './middleware';
 import router from './router';
 import slugify from './slugify';
-export { spa, middleware, router, slugify };
+import spa from './spa';
+export { middleware, router, slugify, spa };
 export * from './types';

package/build/index.js

@@ -1,6 +1,6 @@
-import spa from './spa';
 import middleware from './middleware';
 import router from './router';
 import slugify from './slugify';
-export { spa, middleware, router, slugify };
+import spa from './spa';
+export { middleware, router, slugify, spa };
 export * from './types';

package/build/middleware/dispatch.d.ts

@@ -1,5 +1,5 @@
-import { Router } from '../types';
-declare const _default: (request: {
+import { Middleware, Request, Router } from '../types';
+declare const _default: <R>(request: {
     data: ReturnType<Router['match']>;
-}) => unknown;
+}) => Middleware<Request, R>;
 export default _default;

package/build/middleware/index.d.ts

@@ -2,16 +2,16 @@ import factory from '@esportsplus/middleware';
 import dispatch from './dispatch';
 import match from './match';
 declare const _default: {
-    dispatch: (request: {
+    dispatch: <R>(request: {
         data: {
             parameters?: Record<PropertyKey, unknown> | undefined;
             route?: import("../router/route").Route | undefined;
         };
-    }) => 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 }?: {
+    }) => import("@esportsplus/middleware/build/types").Middleware<import("../types").Request, R>;
+    factory: <I, R_1>(...middleware: import("@esportsplus/middleware/build/types").Middleware<I, R_1>[]) => import("@esportsplus/middleware/build/types").Next<I, R_1>;
+    match: <R_2>(router: import("../router").Router, { spa }?: {
         spa?: boolean | undefined;
-    }) => (request: import("../types").Request, next: import("@esportsplus/middleware/build/types").Next<import("../types").Request, unknown>) => unknown;
+    }) => import("@esportsplus/middleware/build/types").Middleware<import("../types").Request, R_2>;
 };
 export default _default;
 export { dispatch, factory, match };

package/build/middleware/match.d.ts

@@ -1,5 +1,5 @@
-import { Next, Request, Router } from '../types';
-declare const _default: (router: Router, { spa }?: {
+import { Middleware, Request, Router } from '../types';
+declare const _default: <R>(router: Router, { spa }?: {
     spa?: boolean | undefined;
-}) => (request: Request, next: Next<Request, unknown>) => unknown;
+}) => Middleware<Request, R>;
 export default _default;

package/build/spa.d.ts

@@ -1,17 +1,16 @@
-import { Request, Router } from './types';
-type Cache = {
-    factory: typeof request;
-    state: Request;
+import { Router } from './types';
+type Cache<T = Record<string, unknown>> = {
+    factory: () => T;
+    state: T;
 };
-declare const request: (url?: string) => Request;
-declare const _default: (router: Router, state: Cache['state'], factory?: Cache['factory']) => {
+declare const _default: (router: Router, fn?: Cache['factory']) => {
     back: () => void;
     forward: () => void;
     redirect: (path: string, { state, values }: {
         state?: Record<PropertyKey, unknown> | undefined;
         values?: unknown[] | undefined;
     }) => void;
-    request: (url?: string) => Request;
+    request: Record<string, unknown>;
     uri: (path: string, values?: unknown[]) => string;
 };
 export default _default;

package/build/spa.js

@@ -1,15 +1,5 @@
 let cache = [];
-function update() {
-    for (let i = 0, n = cache.length; i < n; i++) {
-        let { factory, state } = cache[i], values = factory();
-        for (let key in values) {
-            state[key] = values[key];
-        }
-    }
-}
-const back = () => window.history.back();
-const forward = () => window.history.forward();
-const request = (url = window?.location?.href || '') => {
+function request(url = window?.location?.href || '') {
     let { hash, hostname, href, origin, port, protocol } = new URL(url), path = hash?.replace('#/', '/')?.split('?') || ['/', ''];
     return {
         data: {},
@@ -22,10 +12,21 @@ const request = (url = window?.location?.href || '') => {
         protocol,
         query: Object.fromEntries((new URLSearchParams(path[1])).entries())
     };
-};
-export default (router, state, factory) => {
+}
+function update() {
+    for (let i = 0, n = cache.length; i < n; i++) {
+        let { factory, state } = cache[i], values = factory();
+        for (let key in values) {
+            state[key] = values[key];
+        }
+    }
+}
+const back = () => window.history.back();
+const forward = () => window.history.forward();
+export default (router, fn = request) => {
+    let state = {};
     cache.push({
-        factory: factory || request,
+        factory: fn,
         state
     });
     update();
@@ -43,7 +44,7 @@ export default (router, state, factory) => {
             }
             window.history.pushState(state || {}, '', uri);
         },
-        request: factory || request,
+        request: state,
         uri: (path, values = []) => {
             let uri = router.uri(path, values || []);
             if (uri[0] === '/') {

package/package.json

@@ -16,5 +16,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "./build/index.d.ts",
-    "version": "0.0.13"
+    "version": "0.0.14"
 }

package/src/index.ts

@@ -1,8 +1,8 @@
-import spa from './spa';
 import middleware from './middleware';
 import router from './router';
 import slugify from './slugify';
+import spa from './spa';
 
 
-export { spa, middleware, router, slugify };
+export { middleware, router, slugify, spa };
 export * from './types';

package/src/middleware/dispatch.ts

@@ -1,12 +1,12 @@
-import { Router } from '~/types';
+import { Middleware, Request, Router } from '~/types';
 
 
-export default (request: { data: ReturnType<Router['match']> }) => {
+export default <R>(request: { data: ReturnType<Router['match']> }) => {
     let { route } = request.data;
 
     if (!route) {
         throw new Error(`Routing: route dispatching failed, route is undefined!`);
     }
 
-    return route.dispatcher(request);
+    return route.dispatcher(request) as Middleware<Request, R>;
 };

package/src/middleware/match.ts

@@ -1,10 +1,10 @@
-import { Next, Request, Router } from '~/types';
+import { Middleware, Request, Router } from '~/types';
 
 
-export default (router: Router, { spa }: { spa?: boolean } = {}) => {
+export default <R>(router: Router, { spa }: { spa?: boolean } = {}): Middleware<Request, R> => {
     let subdomain: string | null = null;
 
-    return (request: Request, next: Next<Request, unknown>) => {
+    return (request, next) => {
         if ((typeof request.subdomain !== 'string' && !spa) || subdomain === null) {
             if (router.subdomains) {
                 for (let i = 0, n = router.subdomains.length; i < n; i++) {

package/src/spa.ts

@@ -1,22 +1,38 @@
 import { Request, Router } from './types';
 
 
-type Cache = {
-    factory: typeof request;
-    state: Request;
+type Cache<T = Record<string, unknown>> = {
+    factory: () => T;
+    state: T;
 };
 
 
 let cache: Cache[] = [];
 
 
+function request(url: string = window?.location?.href || ''): Request {
+    let { hash, hostname, href, origin, port, protocol } = new URL( url ),
+        path = hash?.replace('#/', '/')?.split('?') || ['/', ''];
+
+    return {
+        data: {},
+        href,
+        hostname,
+        method: 'GET',
+        origin,
+        path: path[0],
+        port,
+        protocol,
+        query: Object.fromEntries( (new URLSearchParams(path[1])).entries() )
+    };
+}
+
 function update() {
     for (let i = 0, n = cache.length; i < n; i++) {
         let { factory, state } = cache[i],
-            values: Request = factory();
+            values = factory();
 
         for (let key in values) {
-            // @ts-ignore STFU
             state[key] = values[key];
         }
     }
@@ -27,27 +43,12 @@ const back = () => window.history.back();
 
 const forward = () => window.history.forward();
 
-const request = (url: string = window?.location?.href || ''): Request => {
-    let { hash, hostname, href, origin, port, protocol } = new URL( url ),
-        path = hash?.replace('#/', '/')?.split('?') || ['/', ''];
-
-    return {
-        data: {},
-        href,
-        hostname,
-        method: 'GET',
-        origin,
-        path: path[0],
-        port,
-        protocol,
-        query: Object.fromEntries( (new URLSearchParams(path[1])).entries() )
-    };
-};
 
+export default (router: Router, fn: Cache['factory'] = request) => {
+    let state = {} as ReturnType< typeof fn >;
 
-export default (router: Router, state: Cache['state'], factory?: Cache['factory']) => {
     cache.push({
-        factory: factory || request,
+        factory: fn,
         state
     });
 
@@ -71,7 +72,7 @@ export default (router: Router, state: Cache['state'], factory?: Cache['factory'
 
             window.history.pushState(state || {}, '', uri);
         },
-        request: factory || request,
+        request: state,
         uri: (path: string, values: unknown[] = []) => {
             let uri = router.uri(path, values || []);