@visulima/connect 3.0.27 → 4.0.0-alpha.10

package/dist/packem_shared/{EdgeRouter-B-e2l9un.cjs → EdgeRouter-DTvPX_JS.cjs}

@@ -2,19 +2,23 @@
 
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
 
-const withZod = require('./withZod-ULTsdyM5.cjs');
-const Router = require('./Router-Eg_OPxIL.cjs');
+const withZod = require('./withZod-hpoT0ByV.cjs');
+const Router = require('./Router-DMp6zIkp.cjs');
 
-const onNoMatch = async (request) => new Response(request.method === "HEAD" ? null : `Route ${request.method} ${request.url} not found`, { status: 404 });
-const onError = async (error) => {
-  console.error(error);
+const onNoMatch = (request) => new Response(request.method === "HEAD" ? void 0 : `Route ${request.method} ${request.url} not found`, { status: 404 });
+const onError = (error) => {
+  globalThis.console.error(error);
   return new Response("Internal Server Error", { status: 500 });
 };
-const getPathname = (request) => (
-  // eslint-disable-next-line compat/compat
-  (request.nextUrl ?? new URL(request.url)).pathname
-);
+const getPathname = (request) => (request.nextUrl ?? new URL(request.url)).pathname;
 class EdgeRouter {
+  static prepareRequest(request, findResult) {
+    request.params = {
+      ...findResult.params,
+      ...request.params
+      // original params will take precedence
+    };
+  }
   all = this.add.bind(this, "");
   connect = this.add.bind(this, "CONNECT");
   delete = this.add.bind(this, "DELETE");
@@ -40,8 +44,10 @@ class EdgeRouter {
   handler() {
     const { routes } = this.router;
     return async (request, context_) => {
-      const result = this.router.find(request.method, getPathname(request));
-      this.prepareRequest(request, result);
+      const pathname = getPathname(request);
+      const method = request.method;
+      const result = this.router.find(method, pathname);
+      EdgeRouter.prepareRequest(request, result);
       try {
         return await (result.fns.length === 0 || result.middleOnly ? this.onNoMatch(request, context_, routes) : Router.Router.exec(result.fns, request, context_));
       } catch (error) {
@@ -50,44 +56,48 @@ class EdgeRouter {
     };
   }
   async run(request, context_) {
-    const result = this.router.find(request.method, getPathname(request));
+    const pathname = getPathname(request);
+    const method = request.method;
+    const result = this.router.find(method, pathname);
     if (result.fns.length === 0) {
-      return;
+      return void 0;
     }
-    this.prepareRequest(request, result);
-    return await Router.Router.exec(result.fns, request, context_);
+    EdgeRouter.prepareRequest(request, result);
+    return Router.Router.exec(result.fns, request, context_);
   }
   use(base, ...fns) {
+    let resolvedBase;
     if (typeof base === "function" || base instanceof EdgeRouter) {
       fns.unshift(base);
-      base = "/";
+      resolvedBase = "/";
+    } else {
+      resolvedBase = base;
     }
-    this.router.use(base, ...fns.map((function_) => function_ instanceof EdgeRouter ? function_.router : function_));
+    this.router.use(
+      resolvedBase,
+      ...fns.map((function_) => {
+        if (function_ instanceof EdgeRouter) {
+          return function_.router;
+        }
+        return function_;
+      })
+    );
     return this;
   }
   add(method, routeOrFunction, zodOrRouteOrFunction, ...fns) {
+    let resolvedFns;
     if (typeof routeOrFunction === "string" && typeof zodOrRouteOrFunction === "function") {
-      fns = [zodOrRouteOrFunction];
+      resolvedFns = [zodOrRouteOrFunction];
     } else if (typeof zodOrRouteOrFunction === "object") {
-      if (typeof routeOrFunction === "function") {
-        fns = [withZod(zodOrRouteOrFunction, routeOrFunction)];
-      } else {
-        fns = fns.map((function_) => withZod(zodOrRouteOrFunction, function_));
-      }
+      resolvedFns = typeof routeOrFunction === "function" ? [withZod(zodOrRouteOrFunction, routeOrFunction)] : fns.map((function_) => withZod(zodOrRouteOrFunction, function_));
     } else if (typeof zodOrRouteOrFunction === "function") {
-      fns = [zodOrRouteOrFunction];
+      resolvedFns = [zodOrRouteOrFunction];
+    } else {
+      resolvedFns = fns;
     }
-    this.router.add(method, routeOrFunction, ...fns);
+    this.router.add(method, routeOrFunction, ...resolvedFns);
     return this;
   }
-  // eslint-disable-next-line class-methods-use-this
-  prepareRequest(request, findResult) {
-    request.params = {
-      ...findResult.params,
-      ...request.params
-      // original params will take precedence
-    };
-  }
 }
 const createEdgeRouter = (options = {}) => new EdgeRouter(options);
 

package/dist/packem_shared/Router-CT_g_29S.mjs

@@ -0,0 +1,168 @@
+import { parse } from 'regexparam';
+
+class Router {
+  constructor(base = "/", routes = []) {
+    this.base = base;
+    this.routes = routes;
+  }
+  base;
+  routes;
+  static exec(fns, ...arguments_) {
+    let index = 0;
+    const next = () => {
+      index += 1;
+      const currentFunction = fns[index];
+      if (currentFunction === void 0) {
+        return Promise.resolve();
+      }
+      return currentFunction(...arguments_, next);
+    };
+    return fns[index](...arguments_, next);
+  }
+  static extractRegExpParams(matches) {
+    const result = {};
+    if (matches.groups === void 0) {
+      return result;
+    }
+    for (const key of Object.keys(matches.groups)) {
+      result[key] = matches.groups[key];
+    }
+    return result;
+  }
+  static extractKeyedParams(matches, keys) {
+    const result = {};
+    for (const [index, parameterKey] of keys.entries()) {
+      result[parameterKey] = matches[index + 1];
+    }
+    return result;
+  }
+  static isMethodMatch(routeMethod, method, isHead) {
+    return routeMethod === method || routeMethod === "" || isHead && routeMethod === "GET";
+  }
+  static matchRoute(route, pathname) {
+    if ("matchAll" in route) {
+      return { matched: true, params: {} };
+    }
+    if (route.keys === false) {
+      const matches = route.pattern.exec(pathname);
+      if (matches === null) {
+        return { matched: false };
+      }
+      return { matched: true, params: Router.extractRegExpParams(matches) };
+    }
+    if (route.keys.length > 0) {
+      const matches = route.pattern.exec(pathname);
+      if (matches === null) {
+        return { matched: false };
+      }
+      return { matched: true, params: Router.extractKeyedParams(matches, route.keys) };
+    }
+    if (route.pattern.test(pathname)) {
+      return { matched: true, params: {} };
+    }
+    return { matched: false };
+  }
+  static resolveRouteFns(routeFns, method, pathname, onSubResult) {
+    return routeFns.flatMap((function_) => {
+      if (function_ instanceof Router) {
+        const { base } = function_;
+        let stripPathname = pathname.slice(base.length);
+        if (!stripPathname.startsWith("/")) {
+          stripPathname = `/${stripPathname}`;
+        }
+        const result = function_.find(method, stripPathname);
+        onSubResult(result.params, result.middleOnly);
+        return result.fns;
+      }
+      return [function_];
+    });
+  }
+  add(method, route, ...fns) {
+    let resolvedRoute;
+    if (typeof route === "function") {
+      fns.unshift(route);
+      resolvedRoute = "";
+    } else {
+      resolvedRoute = route;
+    }
+    if (resolvedRoute === "") {
+      this.routes.push({
+        fns,
+        isMiddleware: false,
+        matchAll: true,
+        method
+      });
+    } else {
+      const { keys, pattern } = parse(resolvedRoute);
+      this.routes.push({
+        fns,
+        isMiddleware: false,
+        keys,
+        method,
+        pattern
+      });
+    }
+    return this;
+  }
+  clone(base) {
+    return new Router(base, [...this.routes]);
+  }
+  find(method, pathname) {
+    let middleOnly = true;
+    const fns = [];
+    const parameters = {};
+    const isHead = method === "HEAD";
+    for (let routeIndex = 0; routeIndex < this.routes.length; routeIndex += 1) {
+      const route = this.routes[routeIndex];
+      if (!Router.isMethodMatch(route.method, method, isHead)) {
+        continue;
+      }
+      const matchResult = Router.matchRoute(route, pathname);
+      if (!matchResult.matched) {
+        continue;
+      }
+      Object.assign(parameters, matchResult.params);
+      fns.push(
+        ...Router.resolveRouteFns(route.fns, method, pathname, (subParams, subMiddleOnly) => {
+          Object.assign(parameters, subParams);
+          if (!subMiddleOnly) {
+            middleOnly = false;
+          }
+        })
+      );
+      if (!route.isMiddleware) {
+        middleOnly = false;
+      }
+    }
+    return { fns, middleOnly, params: parameters };
+  }
+  use(base, ...fns) {
+    let resolvedBase;
+    if (typeof base === "function" || base instanceof Router) {
+      fns.unshift(base);
+      resolvedBase = "/";
+    } else {
+      resolvedBase = base;
+    }
+    const resolvedFns = fns.map((function_) => {
+      if (function_ instanceof Router) {
+        if (typeof resolvedBase === "string") {
+          return function_.clone(resolvedBase);
+        }
+        throw new Error("Mounting a router to RegExp base is not supported");
+      }
+      return function_;
+    });
+    const { keys, pattern } = parse(resolvedBase, true);
+    this.routes.push({
+      fns: resolvedFns,
+      isMiddleware: true,
+      keys,
+      method: "",
+      pattern
+    });
+    return this;
+  }
+}
+
+export { Router };

package/dist/packem_shared/Router-DMp6zIkp.cjs

@@ -0,0 +1,172 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const regexparam = require('regexparam');
+
+class Router {
+  constructor(base = "/", routes = []) {
+    this.base = base;
+    this.routes = routes;
+  }
+  base;
+  routes;
+  static exec(fns, ...arguments_) {
+    let index = 0;
+    const next = () => {
+      index += 1;
+      const currentFunction = fns[index];
+      if (currentFunction === void 0) {
+        return Promise.resolve();
+      }
+      return currentFunction(...arguments_, next);
+    };
+    return fns[index](...arguments_, next);
+  }
+  static extractRegExpParams(matches) {
+    const result = {};
+    if (matches.groups === void 0) {
+      return result;
+    }
+    for (const key of Object.keys(matches.groups)) {
+      result[key] = matches.groups[key];
+    }
+    return result;
+  }
+  static extractKeyedParams(matches, keys) {
+    const result = {};
+    for (const [index, parameterKey] of keys.entries()) {
+      result[parameterKey] = matches[index + 1];
+    }
+    return result;
+  }
+  static isMethodMatch(routeMethod, method, isHead) {
+    return routeMethod === method || routeMethod === "" || isHead && routeMethod === "GET";
+  }
+  static matchRoute(route, pathname) {
+    if ("matchAll" in route) {
+      return { matched: true, params: {} };
+    }
+    if (route.keys === false) {
+      const matches = route.pattern.exec(pathname);
+      if (matches === null) {
+        return { matched: false };
+      }
+      return { matched: true, params: Router.extractRegExpParams(matches) };
+    }
+    if (route.keys.length > 0) {
+      const matches = route.pattern.exec(pathname);
+      if (matches === null) {
+        return { matched: false };
+      }
+      return { matched: true, params: Router.extractKeyedParams(matches, route.keys) };
+    }
+    if (route.pattern.test(pathname)) {
+      return { matched: true, params: {} };
+    }
+    return { matched: false };
+  }
+  static resolveRouteFns(routeFns, method, pathname, onSubResult) {
+    return routeFns.flatMap((function_) => {
+      if (function_ instanceof Router) {
+        const { base } = function_;
+        let stripPathname = pathname.slice(base.length);
+        if (!stripPathname.startsWith("/")) {
+          stripPathname = `/${stripPathname}`;
+        }
+        const result = function_.find(method, stripPathname);
+        onSubResult(result.params, result.middleOnly);
+        return result.fns;
+      }
+      return [function_];
+    });
+  }
+  add(method, route, ...fns) {
+    let resolvedRoute;
+    if (typeof route === "function") {
+      fns.unshift(route);
+      resolvedRoute = "";
+    } else {
+      resolvedRoute = route;
+    }
+    if (resolvedRoute === "") {
+      this.routes.push({
+        fns,
+        isMiddleware: false,
+        matchAll: true,
+        method
+      });
+    } else {
+      const { keys, pattern } = regexparam.parse(resolvedRoute);
+      this.routes.push({
+        fns,
+        isMiddleware: false,
+        keys,
+        method,
+        pattern
+      });
+    }
+    return this;
+  }
+  clone(base) {
+    return new Router(base, [...this.routes]);
+  }
+  find(method, pathname) {
+    let middleOnly = true;
+    const fns = [];
+    const parameters = {};
+    const isHead = method === "HEAD";
+    for (let routeIndex = 0; routeIndex < this.routes.length; routeIndex += 1) {
+      const route = this.routes[routeIndex];
+      if (!Router.isMethodMatch(route.method, method, isHead)) {
+        continue;
+      }
+      const matchResult = Router.matchRoute(route, pathname);
+      if (!matchResult.matched) {
+        continue;
+      }
+      Object.assign(parameters, matchResult.params);
+      fns.push(
+        ...Router.resolveRouteFns(route.fns, method, pathname, (subParams, subMiddleOnly) => {
+          Object.assign(parameters, subParams);
+          if (!subMiddleOnly) {
+            middleOnly = false;
+          }
+        })
+      );
+      if (!route.isMiddleware) {
+        middleOnly = false;
+      }
+    }
+    return { fns, middleOnly, params: parameters };
+  }
+  use(base, ...fns) {
+    let resolvedBase;
+    if (typeof base === "function" || base instanceof Router) {
+      fns.unshift(base);
+      resolvedBase = "/";
+    } else {
+      resolvedBase = base;
+    }
+    const resolvedFns = fns.map((function_) => {
+      if (function_ instanceof Router) {
+        if (typeof resolvedBase === "string") {
+          return function_.clone(resolvedBase);
+        }
+        throw new Error("Mounting a router to RegExp base is not supported");
+      }
+      return function_;
+    });
+    const { keys, pattern } = regexparam.parse(resolvedBase, true);
+    this.routes.push({
+      fns: resolvedFns,
+      isMiddleware: true,
+      keys,
+      method: "",
+      pattern
+    });
+    return this;
+  }
+}
+
+exports.Router = Router;

package/dist/packem_shared/{createRouter-C8hDVJcV.cjs → createRouter-B4-TLOnM.cjs}

@@ -2,16 +2,16 @@
 
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
 
-const withZod = require('./withZod-ULTsdyM5.cjs');
-const Router = require('./Router-Eg_OPxIL.cjs');
+const withZod = require('./withZod-hpoT0ByV.cjs');
+const Router = require('./Router-DMp6zIkp.cjs');
 
-const onNoMatch = async (request, response) => {
+const onNoMatch = (request, response) => {
   response.statusCode = 404;
-  response.end(request.method === "HEAD" ? void 0 : `Route ${request.method} ${request.url} not found`);
+  response.end(request.method === "HEAD" ? void 0 : `Route ${String(request.method)} ${String(request.url)} not found`);
 };
-const onError = async (error, _request, response) => {
+const onError = (error, _request, response) => {
   response.statusCode = 500;
-  console.error(error);
+  globalThis.console.error(error);
   response.end("Internal Server Error");
 };
 const getPathname = (url) => {
@@ -19,6 +19,13 @@ const getPathname = (url) => {
   return queryIndex === -1 ? url : url.slice(0, Math.max(0, queryIndex));
 };
 class NodeRouter {
+  static prepareRequest(request, findResult) {
+    request.params = {
+      ...findResult.params,
+      ...request.params
+      // original params will take precedence
+    };
+  }
   all = this.add.bind(this, "");
   connect = this.add.bind(this, "CONNECT");
   delete = this.add.bind(this, "DELETE");
@@ -44,8 +51,10 @@ class NodeRouter {
   handler() {
     const { routes } = this.router;
     return async (request, response) => {
-      const result = this.router.find(request.method, getPathname(request.url));
-      this.prepareRequest(request, result);
+      const pathname = getPathname(request.url);
+      const method = request.method;
+      const result = this.router.find(method, pathname);
+      NodeRouter.prepareRequest(request, result);
       try {
         await (result.fns.length === 0 || result.middleOnly ? this.onNoMatch(request, response, routes) : Router.Router.exec(result.fns, request, response));
       } catch (error) {
@@ -54,46 +63,48 @@ class NodeRouter {
     };
   }
   async run(request, response) {
-    const result = this.router.find(request.method, getPathname(request.url));
+    const pathname = getPathname(request.url);
+    const method = request.method;
+    const result = this.router.find(method, pathname);
     if (result.fns.length === 0) {
-      return;
+      return void 0;
     }
-    this.prepareRequest(request, result);
-    return await Router.Router.exec(result.fns, request, response);
+    NodeRouter.prepareRequest(request, result);
+    return Router.Router.exec(result.fns, request, response);
   }
   use(base, ...fns) {
+    let resolvedBase;
     if (typeof base === "function" || base instanceof NodeRouter) {
       fns.unshift(base);
-      base = "/";
+      resolvedBase = "/";
+    } else {
+      resolvedBase = base;
     }
-    this.router.use(base, ...fns.map((function_) => function_ instanceof NodeRouter ? function_.router : function_));
+    this.router.use(
+      resolvedBase,
+      ...fns.map((function_) => {
+        if (function_ instanceof NodeRouter) {
+          return function_.router;
+        }
+        return function_;
+      })
+    );
     return this;
   }
   add(method, routeOrFunction, zodOrRouteOrFunction, ...fns) {
+    let resolvedFns;
     if (typeof routeOrFunction === "string" && typeof zodOrRouteOrFunction === "function") {
-      fns = [zodOrRouteOrFunction];
+      resolvedFns = [zodOrRouteOrFunction];
     } else if (typeof zodOrRouteOrFunction === "object") {
-      if (typeof routeOrFunction === "function") {
-        fns = [withZod(zodOrRouteOrFunction, routeOrFunction)];
-      } else {
-        fns = fns.map(
-          (function_) => withZod(zodOrRouteOrFunction, function_)
-        );
-      }
+      resolvedFns = typeof routeOrFunction === "function" ? [withZod(zodOrRouteOrFunction, routeOrFunction)] : fns.map((function_) => withZod(zodOrRouteOrFunction, function_));
     } else if (typeof zodOrRouteOrFunction === "function") {
-      fns = [zodOrRouteOrFunction];
+      resolvedFns = [zodOrRouteOrFunction];
+    } else {
+      resolvedFns = fns;
     }
-    this.router.add(method, routeOrFunction, ...fns);
+    this.router.add(method, routeOrFunction, ...resolvedFns);
     return this;
   }
-  // eslint-disable-next-line class-methods-use-this
-  prepareRequest(request, findResult) {
-    request.params = {
-      ...findResult.params,
-      ...request.params
-      // original params will take precedence
-    };
-  }
 }
 const createRouter = (options = {}) => new NodeRouter(options);
 

package/dist/packem_shared/{createRouter-_G1XhaP4.mjs → createRouter-DGGDIRda.mjs}

@@ -1,13 +1,13 @@
-import withZod from './withZod-HYgoC7AX.mjs';
-import { Router } from './Router-ChnTdYfl.mjs';
+import withZod from './withZod-DMHxmHJB.mjs';
+import { Router } from './Router-CT_g_29S.mjs';
 
-const onNoMatch = async (request, response) => {
+const onNoMatch = (request, response) => {
   response.statusCode = 404;
-  response.end(request.method === "HEAD" ? void 0 : `Route ${request.method} ${request.url} not found`);
+  response.end(request.method === "HEAD" ? void 0 : `Route ${String(request.method)} ${String(request.url)} not found`);
 };
-const onError = async (error, _request, response) => {
+const onError = (error, _request, response) => {
   response.statusCode = 500;
-  console.error(error);
+  globalThis.console.error(error);
   response.end("Internal Server Error");
 };
 const getPathname = (url) => {
@@ -15,6 +15,13 @@ const getPathname = (url) => {
   return queryIndex === -1 ? url : url.slice(0, Math.max(0, queryIndex));
 };
 class NodeRouter {
+  static prepareRequest(request, findResult) {
+    request.params = {
+      ...findResult.params,
+      ...request.params
+      // original params will take precedence
+    };
+  }
   all = this.add.bind(this, "");
   connect = this.add.bind(this, "CONNECT");
   delete = this.add.bind(this, "DELETE");
@@ -40,8 +47,10 @@ class NodeRouter {
   handler() {
     const { routes } = this.router;
     return async (request, response) => {
-      const result = this.router.find(request.method, getPathname(request.url));
-      this.prepareRequest(request, result);
+      const pathname = getPathname(request.url);
+      const method = request.method;
+      const result = this.router.find(method, pathname);
+      NodeRouter.prepareRequest(request, result);
       try {
         await (result.fns.length === 0 || result.middleOnly ? this.onNoMatch(request, response, routes) : Router.exec(result.fns, request, response));
       } catch (error) {
@@ -50,46 +59,48 @@ class NodeRouter {
     };
   }
   async run(request, response) {
-    const result = this.router.find(request.method, getPathname(request.url));
+    const pathname = getPathname(request.url);
+    const method = request.method;
+    const result = this.router.find(method, pathname);
     if (result.fns.length === 0) {
-      return;
+      return void 0;
     }
-    this.prepareRequest(request, result);
-    return await Router.exec(result.fns, request, response);
+    NodeRouter.prepareRequest(request, result);
+    return Router.exec(result.fns, request, response);
   }
   use(base, ...fns) {
+    let resolvedBase;
     if (typeof base === "function" || base instanceof NodeRouter) {
       fns.unshift(base);
-      base = "/";
+      resolvedBase = "/";
+    } else {
+      resolvedBase = base;
     }
-    this.router.use(base, ...fns.map((function_) => function_ instanceof NodeRouter ? function_.router : function_));
+    this.router.use(
+      resolvedBase,
+      ...fns.map((function_) => {
+        if (function_ instanceof NodeRouter) {
+          return function_.router;
+        }
+        return function_;
+      })
+    );
     return this;
   }
   add(method, routeOrFunction, zodOrRouteOrFunction, ...fns) {
+    let resolvedFns;
     if (typeof routeOrFunction === "string" && typeof zodOrRouteOrFunction === "function") {
-      fns = [zodOrRouteOrFunction];
+      resolvedFns = [zodOrRouteOrFunction];
     } else if (typeof zodOrRouteOrFunction === "object") {
-      if (typeof routeOrFunction === "function") {
-        fns = [withZod(zodOrRouteOrFunction, routeOrFunction)];
-      } else {
-        fns = fns.map(
-          (function_) => withZod(zodOrRouteOrFunction, function_)
-        );
-      }
+      resolvedFns = typeof routeOrFunction === "function" ? [withZod(zodOrRouteOrFunction, routeOrFunction)] : fns.map((function_) => withZod(zodOrRouteOrFunction, function_));
     } else if (typeof zodOrRouteOrFunction === "function") {
-      fns = [zodOrRouteOrFunction];
+      resolvedFns = [zodOrRouteOrFunction];
+    } else {
+      resolvedFns = fns;
     }
-    this.router.add(method, routeOrFunction, ...fns);
+    this.router.add(method, routeOrFunction, ...resolvedFns);
     return this;
   }
-  // eslint-disable-next-line class-methods-use-this
-  prepareRequest(request, findResult) {
-    request.params = {
-      ...findResult.params,
-      ...request.params
-      // original params will take precedence
-    };
-  }
 }
 const createRouter = (options = {}) => new NodeRouter(options);