@visulima/connect 4.0.0-alpha.6 → 4.0.0-alpha.8

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-_G1XhaP4.mjs → createRouter-BRGcdDwj.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,45 @@ 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);
 

package/dist/packem_shared/{createRouter-C8hDVJcV.cjs → createRouter-D-kQjdxT.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,45 @@ 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/expressWrapper-CeTFmeNH.mjs

@@ -0,0 +1,14 @@
+const expressWrapper = (function_) => async (request, response, next) => {
+  await new Promise((resolve, reject) => {
+    function_(request, response, (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    });
+  });
+  return next();
+};
+
+export { expressWrapper as default };

package/dist/packem_shared/expressWrapper-oEj2tv9s.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+const expressWrapper = (function_) => async (request, response, next) => {
+  await new Promise((resolve, reject) => {
+    function_(request, response, (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    });
+  });
+  return next();
+};
+
+module.exports = expressWrapper;

package/dist/packem_shared/{sendJson-DwLYLDbt.mjs → sendJson-Cd6CsJC_.mjs}

@@ -1,7 +1,7 @@
 const sendJson = (response, statusCode, jsonBody) => {
   response.setHeader("content-type", "application/json; charset=utf-8");
   response.statusCode = statusCode;
-  response.end(JSON.stringify(jsonBody, null, 2));
+  response.end(JSON.stringify(jsonBody, void 0, 2));
 };
 
 export { sendJson as default };

package/dist/packem_shared/{sendJson-pJY2tT2n.cjs → sendJson-DjC80Qht.cjs}

@@ -3,7 +3,7 @@
 const sendJson = (response, statusCode, jsonBody) => {
   response.setHeader("content-type", "application/json; charset=utf-8");
   response.statusCode = statusCode;
-  response.end(JSON.stringify(jsonBody, null, 2));
+  response.end(JSON.stringify(jsonBody, void 0, 2));
 };
 
 module.exports = sendJson;

package/dist/packem_shared/{withZod-HYgoC7AX.mjs → withZod-DMHxmHJB.mjs}

@@ -1,15 +1,12 @@
 import createHttpError from 'http-errors';
-import { ZodError } from 'zod';
+import * as z from 'zod';
 
 const withZod = (schema, handler) => async (request, response, next) => {
-  let transformedRequest = request;
+  let transformedRequest;
   try {
     transformedRequest = await schema.parseAsync(request);
   } catch (error) {
-    let { message } = error;
-    if (error instanceof ZodError && typeof error.format === "function") {
-      message = error.issues.map((issue) => `${issue.path.join("/")} - ${issue.message}`).join("/n");
-    }
+    const message = error instanceof z.ZodError && typeof error.format === "function" ? error.issues.map((issue) => `${issue.path.join("/")} - ${issue.message}`).join("/n") : error.message;
     throw createHttpError(422, message);
   }
   return handler(transformedRequest, response, next);

package/dist/packem_shared/withZod-hpoT0ByV.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+const createHttpError = require('http-errors');
+const z = require('zod');
+
+const _interopDefaultCompat = e => e && typeof e === 'object' && 'default' in e ? e.default : e;
+
+function _interopNamespaceCompat(e) {
+    if (e && typeof e === 'object' && 'default' in e) return e;
+    const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
+    if (e) {
+        for (const k in e) {
+            n[k] = e[k];
+        }
+    }
+    n.default = e;
+    return n;
+}
+
+const createHttpError__default = /*#__PURE__*/_interopDefaultCompat(createHttpError);
+const z__namespace = /*#__PURE__*/_interopNamespaceCompat(z);
+
+const withZod = (schema, handler) => async (request, response, next) => {
+  let transformedRequest;
+  try {
+    transformedRequest = await schema.parseAsync(request);
+  } catch (error) {
+    const message = error instanceof z__namespace.ZodError && typeof error.format === "function" ? error.issues.map((issue) => `${issue.path.join("/")} - ${issue.message}`).join("/n") : error.message;
+    throw createHttpError__default(422, message);
+  }
+  return handler(transformedRequest, response, next);
+};
+
+module.exports = withZod;