@stacksjs/router 0.57.4 → 0.58.20

package/README.md

@@ -15,7 +15,7 @@ wip
 wip
 
 ```bash
-pnpm i -D @stacksjs/actions
+bun install -d @stacksjs/actions
 ```
 
 Now, you can use it in your project:
@@ -31,7 +31,7 @@ Learn more in the docs.
 ## 🧪 Testing
 
 ```bash
-pnpm test
+bun test
 ```
 
 ## 📈 Changelog
@@ -50,10 +50,10 @@ For help, discussion about best practices, or any other conversation that would
 
 For casual chit-chat with others using this package:
 
-[Join the Stacks Discord Server](https://discord.ow3.org)
+[Join the Stacks Discord Server](https://discord.gg/stacksjs)
 
 ## 📄 License
 
 The MIT License (MIT). Please see [LICENSE](https://github.com/stacksjs/stacks/tree/main/LICENSE.md) for more information.
 
-Made with ❤️
+Made with 💙

package/dist/index.js

@@ -0,0 +1,841 @@
+// @bun
+// src/middleware.ts
+import fs from "fs";
+import {promisify} from "util";
+
+// /Users/chrisbreuer/Code/stacks/storage/framework/core/src/path/src/index.ts
+import process2 from "process";
+
+// /Users/chrisbreuer/Code/stacks/node_modules/pathe/dist/shared/pathe.ff20891b.mjs
+var normalizeWindowsPath = function(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+};
+var cwd = function() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+};
+var normalizeString = function(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0;index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1)
+        ;
+      else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+};
+var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+var _UNC_REGEX = /^[/\\]{2}/;
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+var _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+var sep = "/";
+var delimiter = ":";
+var normalize = function(path) {
+  if (path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+var join = function(...arguments_) {
+  if (arguments_.length === 0) {
+    return ".";
+  }
+  let joined;
+  for (const argument of arguments_) {
+    if (argument && argument.length > 0) {
+      if (joined === undefined) {
+        joined = argument;
+      } else {
+        joined += `/${argument}`;
+      }
+    }
+  }
+  if (joined === undefined) {
+    return ".";
+  }
+  return normalize(joined.replace(/\/\/+/g, "/"));
+};
+var resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1;index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+var isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+var toNamespacedPath = function(p) {
+  return normalizeWindowsPath(p);
+};
+var _EXTNAME_RE = /.(\.[^./]+)$/;
+var extname = function(p) {
+  const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+  return match && match[1] || "";
+};
+var relative = function(from, to) {
+  const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
+    return _to.join("/");
+  }
+  const _fromCopy = [..._from];
+  for (const segment of _fromCopy) {
+    if (_to[0] !== segment) {
+      break;
+    }
+    _from.shift();
+    _to.shift();
+  }
+  return [..._from.map(() => ".."), ..._to].join("/");
+};
+var dirname = function(p) {
+  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
+    segments[0] += "/";
+  }
+  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+var format = function(p) {
+  const segments = [p.root, p.dir, p.base ?? p.name + p.ext].filter(Boolean);
+  return normalizeWindowsPath(p.root ? resolve(...segments) : segments.join("/"));
+};
+var basename = function(p, extension) {
+  const lastSegment = normalizeWindowsPath(p).split("/").pop();
+  return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
+var parse = function(p) {
+  const root = normalizeWindowsPath(p).split("/").shift() || "/";
+  const base = basename(p);
+  const extension = extname(base);
+  return {
+    root,
+    dir: dirname(p),
+    base,
+    ext: extension,
+    name: base.slice(0, base.length - extension.length)
+  };
+};
+// /Users/chrisbreuer/Code/stacks/storage/framework/core/src/path/src/index.ts
+function actionsPath(path2) {
+  return corePath(`actions/src/${path2 || ""}`);
+}
+function relativeActionsPath(path2) {
+  return relative(projectPath(), actionsPath(path2));
+}
+function aiPath(path2) {
+  return corePath(`ai/${path2 || ""}`);
+}
+function assetsPath(path2) {
+  return resourcesPath(`assets/${path2 || ""}`);
+}
+function aliasPath() {
+  return corePath("alias/src/index.ts");
+}
+function analyticsPath(path2) {
+  return corePath(`analytics/${path2 || ""}`);
+}
+function arraysPath(path2) {
+  return corePath(`arrays/${path2 || ""}`);
+}
+function appPath(path2) {
+  return projectPath(`app/${path2 || ""}`);
+}
+function authPath(path2) {
+  return corePath(`auth/${path2 || ""}`);
+}
+function buildPath(path2) {
+  return corePath(`build/${path2 || ""}`);
+}
+function buildEnginePath(path2) {
+  return buildPath(`${path2 || ""}`);
+}
+function libsPath(path2) {
+  return frameworkPath(`libs/${path2 || ""}`);
+}
+function libsEntriesPath(path2) {
+  return libsPath(`entries/${path2 || ""}`);
+}
+function cachePath(path2) {
+  return corePath(`cache/${path2 || ""}`);
+}
+function chatPath(path2) {
+  return corePath(`chat/${path2 || ""}`);
+}
+function cliPath(path2) {
+  return corePath(`cli/${path2 || ""}`);
+}
+function cloudPath(path2) {
+  return corePath(`cloud/${path2 || ""}`);
+}
+function collectionsPath(path2) {
+  return corePath(`collections/${path2 || ""}`);
+}
+function componentsPath(path2) {
+  return resourcesPath(`components/${path2 || ""}`);
+}
+function configPath(path2) {
+  return corePath(`config/${path2 || ""}`);
+}
+function corePath(path2) {
+  return frameworkPath(`core/src/${path2 || ""}`);
+}
+function customElementsDataPath() {
+  return corePath("custom-elements.json");
+}
+function databasePath(path2) {
+  return corePath(`database/${path2 || ""}`);
+}
+function datetimePath(path2) {
+  return corePath(`datetime/${path2 || ""}`);
+}
+function developmentPath(path2) {
+  return corePath(`development/${path2 || ""}`);
+}
+function desktopPath(path2) {
+  return corePath(`desktop/${path2 || ""}`);
+}
+function docsPath(path2) {
+  return corePath(`docs/${path2 || ""}`);
+}
+function dnsPath(path2) {
+  return corePath(`domains/${path2 || ""}`);
+}
+function emailPath(path2) {
+  return notificationsPath(`email/${path2 || ""}`);
+}
+function enumsPath(path2) {
+  return corePath(`enums/${path2 || ""}`);
+}
+function errorHandlingPath(path2) {
+  return corePath(`error-handling/${path2 || ""}`);
+}
+function eventsPath(path2) {
+  return corePath(`events/${path2 || ""}`);
+}
+function coreEnvPath(path2) {
+  return corePath(`env/${path2 || ""}`);
+}
+function examplesPath(type) {
+  return frameworkPath(`examples/${type || ""}`);
+}
+function fakerPath(path2) {
+  return corePath(`faker/${path2 || ""}`);
+}
+function frameworkPath(path2) {
+  return projectStoragePath(`framework/${path2 || ""}`);
+}
+function healthPath(path2) {
+  return corePath(`health/${path2 || ""}`);
+}
+function functionsPath(path2) {
+  return resourcesPath(`functions/${path2 || ""}`);
+}
+function gitPath(path2) {
+  return corePath(`git/${path2 || ""}`);
+}
+function langPath(path2) {
+  return projectPath(`lang/${path2 || ""}`);
+}
+function libraryEntryPath(type) {
+  return libsEntriesPath(`${type}.ts`);
+}
+function lintPath(path2) {
+  return corePath(`lint/${path2 || ""}`);
+}
+function loggingPath(path2) {
+  return corePath(`logging/${path2 || ""}`);
+}
+function modulesPath(path2) {
+  return resourcesPath(`modules/${path2 || ""}`);
+}
+function notificationsPath(path2) {
+  return corePath(`notifications/${path2 || ""}`);
+}
+function ormPath(path2) {
+  return corePath(`orm/${path2 || ""}`);
+}
+function objectsPath(path2) {
+  return corePath(`objects/${path2 || ""}`);
+}
+function onboardingPath(path2) {
+  return projectPath(`${path2 || "views/dashboard/onboarding"}`);
+}
+function packageJsonPath(type) {
+  if (type === "vue-components")
+    return frameworkPath("libs/components/vue/package.json");
+  if (type === "web-components")
+    return frameworkPath("libs/components/web/package.json");
+  return frameworkPath(`libs/${type}/package.json`);
+}
+function viewsPath(path2) {
+  return resourcesPath(`views/${path2 || ""}`);
+}
+function pathPath(path2) {
+  return corePath(`path/${path2 || ""}`);
+}
+function paymentsPath(path2) {
+  return corePath(`payments/${path2 || ""}`);
+}
+function projectPath(filePath = "") {
+  let path2 = process2.cwd();
+  while (path2.includes("storage"))
+    path2 = resolve(path2, "..");
+  return resolve(path2, filePath);
+}
+function projectConfigPath(path2) {
+  return projectPath(`config/${path2 || ""}`);
+}
+function projectStoragePath(path2) {
+  return projectPath(`storage/${path2 || ""}`);
+}
+function publicPath(path2) {
+  return projectPath(`public/${path2 || ""}`);
+}
+function pushPath(path2) {
+  return notificationsPath(`push/${path2 || ""}`);
+}
+function queryBuilderPath(path2) {
+  return corePath(`query-builder/${path2 || ""}`);
+}
+function queuePath(path2) {
+  return corePath(`queue/${path2 || ""}`);
+}
+function realtimePath(path2) {
+  return corePath(`realtime/${path2 || ""}`);
+}
+function resourcesPath(path2) {
+  return projectPath(`resources/${path2 || ""}`);
+}
+function replPath(path2) {
+  return corePath(`repl/${path2 || ""}`);
+}
+function routerPath(path2) {
+  return corePath(`router/${path2 || ""}`);
+}
+function routesPath(path2) {
+  return projectPath(`routes/${path2 || ""}`);
+}
+function searchEnginePath(path2) {
+  return corePath(`search-engine/${path2 || ""}`);
+}
+function settingsPath(path2) {
+  return projectPath(`${path2 || "views/dashboard/settings"}`);
+}
+function scriptsPath(path2) {
+  return frameworkPath(`core/scripts/${path2 || ""}`);
+}
+function schedulerPath(path2) {
+  return corePath(`scheduler/${path2 || ""}`);
+}
+function signalsPath(path2) {
+  return corePath(`signals/${path2 || ""}`);
+}
+function slugPath(path2) {
+  return corePath(`slug/${path2 || ""}`);
+}
+function smsPath(path2) {
+  return notificationsPath(`sms/${path2 || ""}`);
+}
+function storagePath(path2) {
+  return corePath(`storage/${path2 || ""}`);
+}
+function storesPath(path2) {
+  return resourcesPath(`stores/${path2 || ""}`);
+}
+function securityPath(path2) {
+  return corePath(`security/${path2 || ""}`);
+}
+function serverPath(path2) {
+  return corePath(`server/${path2 || ""}`);
+}
+function serverlessPath(path2) {
+  return corePath(`serverless/${path2 || ""}`);
+}
+function stacksPath(path2) {
+  return frameworkPath(`src/${path2 || ""}`);
+}
+function stringsPath(path2) {
+  return corePath(`strings/${path2 || ""}`);
+}
+function testingPath(path2) {
+  return corePath(`testing/${path2 || ""}`);
+}
+function tinkerPath(path2) {
+  return corePath(`tinker/${path2 || ""}`);
+}
+function testsPath(path2) {
+  return frameworkPath(`tests/${path2 || ""}`);
+}
+function typesPath(path2) {
+  return corePath(`types/${path2 || ""}`);
+}
+function uiPath(path2) {
+  return corePath(`ui/${path2 || ""}`);
+}
+function utilsPath(path2) {
+  return corePath(`utils/${path2 || ""}`);
+}
+function validationPath(path2) {
+  return corePath(`validation/${path2 || ""}`);
+}
+function vitePath(path2) {
+  return corePath(`vite/${path2 || ""}`);
+}
+function xRayPath(path2) {
+  return frameworkPath(`stacks/x-ray/${path2 || ""}`);
+}
+var path2 = {
+  actionsPath,
+  aiPath,
+  assetsPath,
+  relativeActionsPath,
+  aliasPath,
+  analyticsPath,
+  arraysPath,
+  appPath,
+  authPath,
+  buildEnginePath,
+  libsEntriesPath,
+  buildPath,
+  cachePath,
+  chatPath,
+  cliPath,
+  cloudPath,
+  collectionsPath,
+  componentsPath,
+  configPath,
+  projectConfigPath,
+  corePath,
+  customElementsDataPath,
+  databasePath,
+  datetimePath,
+  developmentPath,
+  desktopPath,
+  docsPath,
+  dnsPath,
+  emailPath,
+  enumsPath,
+  errorHandlingPath,
+  eventsPath,
+  coreEnvPath,
+  healthPath,
+  examplesPath,
+  fakerPath,
+  frameworkPath,
+  storagePath,
+  functionsPath,
+  gitPath,
+  langPath,
+  libsPath,
+  libraryEntryPath,
+  lintPath,
+  loggingPath,
+  modulesPath,
+  ormPath,
+  objectsPath,
+  onboardingPath,
+  notificationsPath,
+  packageJsonPath,
+  viewsPath,
+  pathPath,
+  paymentsPath,
+  projectPath,
+  projectStoragePath,
+  publicPath,
+  pushPath,
+  queryBuilderPath,
+  queuePath,
+  realtimePath,
+  resourcesPath,
+  replPath,
+  routerPath,
+  routesPath,
+  searchEnginePath,
+  schedulerPath,
+  settingsPath,
+  smsPath,
+  signalsPath,
+  slugPath,
+  scriptsPath,
+  securityPath,
+  serverPath,
+  serverlessPath,
+  stacksPath,
+  stringsPath,
+  storesPath,
+  testingPath,
+  testsPath,
+  tinkerPath,
+  typesPath,
+  uiPath,
+  utilsPath,
+  validationPath,
+  vitePath,
+  xRayPath,
+  basename,
+  delimiter,
+  dirname,
+  extname,
+  format,
+  isAbsolute,
+  join,
+  normalize,
+  normalizeString,
+  parse,
+  relative,
+  resolve,
+  sep,
+  toNamespacedPath
+};
+
+// src/middleware.ts
+async function importMiddlewares(directory) {
+  const middlewares = [];
+  const files = await readdir(directory);
+  for (const file of files) {
+    const imported = await import(path2.join(directory, file));
+    middlewares.push(imported.default);
+  }
+  return middlewares;
+}
+
+class Middleware {
+  name;
+  priority;
+  handle;
+  constructor(data) {
+    this.name = data.name;
+    this.priority = data.priority;
+    this.handle = data.handle;
+  }
+}
+var readdir = promisify(fs.readdir);
+var middlewares = await importMiddlewares(appPath("middleware"));
+// src/request.ts
+class Request {
+  query = {};
+  params = null;
+  addQuery(url) {
+    this.query = Object.fromEntries(url.searchParams);
+  }
+  get(element) {
+    return this.query[element];
+  }
+  all() {
+    return this.query;
+  }
+  has(element) {
+    return element in this.query;
+  }
+  isEmpty() {
+    return Object.keys(this.query).length === 0;
+  }
+  extractParamsFromRoute(routePattern, pathname) {
+    const pattern = new RegExp(`^${routePattern.replace(/:(\w+)/g, (match2, paramName) => `(?<${paramName}>\\w+)`)}\$`);
+    const match = pattern.exec(pathname);
+    if (match?.groups)
+      this.params = match?.groups;
+  }
+  getParams(key) {
+    return this.params ? this.params[key] || null : null;
+  }
+}
+var request = new Request;
+// src/server.ts
+import {extname as extname2} from "path";
+import {URL} from "url";
+import {localUrl} from "@stacksjs/config";
+async function serve(options = {}) {
+  const hostname = options.host || options.tunnel ? await localUrl({ type: "backend" }) : "127.0.0.1";
+  const port = options.port || 3000;
+  Bun.serve({
+    hostname,
+    port,
+    fetch(req) {
+      console.log(req);
+      return serverResponse(req);
+    }
+  });
+}
+async function serverResponse(req) {
+  console.log("serverResponse", req);
+  const routesList = await route.getRoutes();
+  const url = new URL(req.url);
+  const foundRoute = routesList.find((route2) => {
+    const pattern = new RegExp(`^${route2.uri.replace(/:\w+/g, "\\w+")}\$`);
+    return pattern.test(url.pathname);
+  });
+  if (!foundRoute)
+    return new Response("Not found", { status: 404 });
+  addRouteParamsAndQuery(url, foundRoute);
+  executeMiddleware(foundRoute);
+  return execute(foundRoute, req, { statusCode: foundRoute?.statusCode });
+}
+var addRouteParamsAndQuery = function(url, route2) {
+  if (!isObjectNotEmpty(url.searchParams))
+    request.addQuery(url);
+  request.extractParamsFromRoute(route2.uri, url.pathname);
+};
+var executeMiddleware = function(route2) {
+  const { middleware: middleware2 = null } = route2;
+  if (middleware2 && middlewares && isObjectNotEmpty(middlewares)) {
+    if (isString(middleware2)) {
+      const middlewareItem = middlewares.find((middlewareItem2) => {
+        return middlewareItem2.name === middleware2;
+      });
+      if (middlewareItem)
+        middlewareItem.handle();
+    } else {
+      middleware2.forEach((m) => {
+        const middlewareItem = middlewares.find((middlewareItem2) => {
+          return middlewareItem2.name === m;
+        });
+        if (middlewareItem)
+          middlewareItem.handle();
+      });
+    }
+  }
+};
+var execute = function(route2, request3, { statusCode }) {
+  if (!statusCode)
+    statusCode = 200;
+  if (route2?.method === "GET" && (statusCode === 301 || statusCode === 302)) {
+    const callback = String(route2.callback);
+    const response = Response.redirect(callback, statusCode);
+    return noCache(response);
+  }
+  if (route2?.method !== request3.method)
+    return new Response("Method not allowed", { status: 405 });
+  if (isString(route2.callback) && extname2(route2.callback) === ".html") {
+    try {
+      const fileContent = Bun.file(route2.callback);
+      return new Response(fileContent, { headers: { "Content-Type": "text/html" } });
+    } catch (error) {
+      return new Response("Error reading the HTML file", { status: 500 });
+    }
+  }
+  if (isString(route2.callback))
+    return new Response(route2.callback);
+  if (isFunction(route2.callback)) {
+    const result = route2.callback();
+    return new Response(JSON.stringify(result));
+  }
+  if (isObject(route2.callback))
+    return new Response(JSON.stringify(route2.callback));
+  return new Response("Unknown callback type.", { status: 500 });
+};
+var noCache = function(response) {
+  response.headers.set("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
+  response.headers.set("Pragma", "no-cache");
+  response.headers.set("Expires", "0");
+  return response;
+};
+var isString = function(val) {
+  return typeof val === "string";
+};
+var isObjectNotEmpty = function(obj) {
+  return Object.keys(obj).length > 0;
+};
+var isFunction = function(val) {
+  return typeof val === "function";
+};
+var isObject = function(val) {
+  return val !== null && typeof val === "object" && !Array.isArray(val);
+};
+// src/router.ts
+class Router {
+  routes = [];
+  addRoute(method, uri, callback, statusCode) {
+    const name = uri.replace(/\//g, ".").replace(/:/g, "");
+    const pattern = new RegExp(`^${uri.replace(/:[a-zA-Z]+/g, (_match) => {
+      return "([a-zA-Z0-9-]+)";
+    })}\$`);
+    let routeCallback;
+    if (typeof callback === "string" || typeof callback === "object") {
+      routeCallback = () => callback;
+    } else {
+      routeCallback = callback;
+    }
+    this.routes.push({
+      name,
+      method,
+      url: uri,
+      uri,
+      callback: routeCallback,
+      pattern,
+      statusCode,
+      paramNames: []
+    });
+  }
+  get(path5, callback) {
+    this.addRoute("GET", path5, callback, 200);
+    return this;
+  }
+  post(path5, callback) {
+    this.addRoute("POST", path5, callback, 201);
+    return this;
+  }
+  view(path5, callback) {
+    this.addRoute("GET", path5, callback, 200);
+    return this;
+  }
+  redirect(path5, callback, _status) {
+    this.addRoute("GET", path5, callback, 302);
+    return this;
+  }
+  delete(path5, callback) {
+    this.addRoute("DELETE", path5, callback, 204);
+    return this;
+  }
+  patch(path5, callback) {
+    this.addRoute("PATCH", path5, callback, 202);
+    return this;
+  }
+  put(path5, callback) {
+    this.addRoute("PUT", path5, callback, 202);
+    return this;
+  }
+  group(options, callback) {
+    let cb;
+    if (typeof options === "function") {
+      cb = options;
+      options = {};
+    } else {
+      if (!callback)
+        throw new Error("Missing callback function for route group.");
+      cb = callback;
+    }
+    const { prefix = "", middleware: middleware2 = [] } = options;
+    const originalRoutes = this.routes;
+    this.routes = [];
+    cb();
+    this.routes.forEach((r) => {
+      r.uri = `${prefix}${r.uri}`;
+      if (middleware2.length)
+        r.middleware = middleware2;
+      originalRoutes.push(r);
+      return this;
+    });
+    this.routes = originalRoutes;
+    return this;
+  }
+  name(name) {
+    this.routes[this.routes.length - 1].name = name;
+    return this;
+  }
+  middleware(middleware2) {
+    this.routes[this.routes.length - 1].middleware = middleware2;
+    return this;
+  }
+  prefix(prefix) {
+    this.routes[this.routes.length - 1].prefix = prefix;
+    return this;
+  }
+  async getRoutes() {
+    await import(projectPath("routes/api.ts"));
+    return this.routes;
+  }
+}
+var route = new Router;
+export {
+  serverResponse,
+  serve,
+  route,
+  request,
+  middlewares,
+  Router,
+  Request,
+  Middleware
+};

package/package.json

@@ -1,17 +1,16 @@
 {
   "name": "@stacksjs/router",
   "type": "module",
-  "version": "0.57.4",
-  "packageManager": "pnpm@8.6.6",
+  "version": "0.58.20",
   "description": "The Stacks framework router.",
   "author": "Chris Breuer",
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
-  "homepage": "https://github.com/stacksjs/stacks/tree/main/.stacks/core/router#readme",
+  "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/src/router#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/stacksjs/stacks.git",
-    "directory": "./.stacks/core/router"
+    "directory": "./storage/framework/core/src/router"
   },
   "bugs": {
     "url": "https://github.com/stacksjs/stacks/issues"
@@ -25,28 +24,39 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs"
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "bun": "./src/*",
+      "import": "./dist/*"
     }
   },
-  "module": "dist/index.mjs",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "contributors": [
-    "Chris Breuer <chris@ow3.org>"
+    "Chris Breuer <chris@stacksjs.org>"
   ],
   "files": [
-    "dist",
-    "README.md"
+    "README.md",
+    "dist"
   ],
+  "scripts": {
+    "build": "bun --bun build.ts",
+    "typecheck": "bun --bun tsc --noEmit",
+    "prepublishOnly": "bun --bun run build"
+  },
   "peerDependencies": {
-    "vue-router": "^4.2.2"
+    "@stacksjs/config": "workspace:*",
+    "unplugin-vue-router": "^0.7.0",
+    "vue-router": "^4.2.5"
   },
-  "devDependencies": {
-    "@stacksjs/development": "0.57.4"
+  "dependencies": {
+    "@stacksjs/config": "workspace:*",
+    "unplugin-vue-router": "^0.7.0",
+    "vue-router": "^4.2.5"
   },
-  "scripts": {
-    "build": "unbuild",
-    "dev": "unbuild --stub",
-    "typecheck": "tsc --noEmit"
+  "devDependencies": {
+    "@stacksjs/development": "workspace:*"
   }
-}
+}

package/LICENSE.md

@@ -1,21 +0,0 @@
-# MIT License
-
-Copyright (c) 2022 Open Web Foundation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/index.d.ts

@@ -1,18 +0,0 @@
-import type { HttpMethod, RouteCallback, RouteGroupOptions } from '@stacksjs/types';
-export declare class Router {
-    private routes;
-    addRoute(method: HttpMethod, url: string, callback: RouteCallback): void;
-    group(options: RouteGroupOptions, callback: () => void): void;
-    before(callback: RouteCallback): void;
-    after(callback: RouteCallback): void;
-    handleRequest(method: HttpMethod, url: string): Promise<any>;
-    get(url: string, callback: RouteCallback): Promise<void>;
-    post(url: string, callback: RouteCallback): Promise<void>;
-    put(url: string, callback: RouteCallback): Promise<void>;
-    patch(url: string, callback: RouteCallback): Promise<void>;
-    delete(url: string, callback: RouteCallback): Promise<void>;
-    private matchRoute;
-    private extractParams;
-    private getMiddleware;
-}
-export declare const route: Router;

package/dist/index.mjs

@@ -1,94 +0,0 @@
-export class Router {
-  constructor() {
-    this.routes = [];
-  }
-  addRoute(method, url, callback) {
-    const paramNames = [];
-    const pattern = new RegExp(`^${url.replace(/:[a-zA-Z]+/g, (match) => {
-      paramNames.push(match.slice(1));
-      return "([a-zA-Z0-9-]+)";
-    })}$`);
-    this.routes.push({ method, pattern, callback, paramNames });
-  }
-  group(options, callback) {
-    const { prefix = "", middleware = [] } = options;
-    const routes = this.routes.slice();
-    this.routes = [];
-    middleware.forEach((m) => {
-      if (m.before)
-        this.before(m.before);
-      if (m.after)
-        this.after(m.after);
-    });
-    callback();
-    this.routes = this.routes.map((r) => {
-      return {
-        ...r,
-        pattern: new RegExp(`^${prefix}${r.pattern.source}$`)
-      };
-    }).concat(routes);
-  }
-  before(callback) {
-    this.routes.unshift({ method: "before", pattern: /^$/, callback, paramNames: [] });
-  }
-  after(callback) {
-    this.routes.push({ method: "after", pattern: /^$/, callback, paramNames: [] });
-  }
-  async handleRequest(method, url) {
-    const route2 = this.matchRoute(method, url);
-    if (!route2)
-      throw new Error("Route not found");
-    const params = this.extractParams(route2, url);
-    const middleware = this.getMiddleware(route2);
-    if (middleware.before)
-      await middleware.before(params);
-    const result = await route2.callback(params);
-    if (middleware.after)
-      await middleware.after(params);
-    return result;
-  }
-  async get(url, callback) {
-    this.addRoute("get", url, callback);
-  }
-  async post(url, callback) {
-    this.addRoute("post", url, callback);
-  }
-  async put(url, callback) {
-    this.addRoute("put", url, callback);
-  }
-  async patch(url, callback) {
-    this.addRoute("patch", url, callback);
-  }
-  async delete(url, callback) {
-    this.addRoute("delete", url, callback);
-  }
-  matchRoute(method, url) {
-    const route2 = this.routes.find((r) => r.method === method && r.pattern.test(url));
-    return route2 || null;
-  }
-  extractParams(route2, url) {
-    const matches = url.match(route2.pattern);
-    const params = {};
-    if (matches) {
-      route2.paramNames.forEach((name, i) => {
-        params[name] = matches[i + 1];
-      });
-    }
-    return params;
-  }
-  getMiddleware(route2) {
-    const before = this.routes.filter((r) => r.method === "before");
-    const after = this.routes.filter((r) => r.method === "after");
-    const middleware = {};
-    before.forEach((b) => {
-      if (b.pattern.test(route2.pattern.source))
-        middleware.before = b.callback;
-    });
-    after.forEach((a) => {
-      if (a.pattern.test(route2.pattern.source))
-        middleware.after = a.callback;
-    });
-    return middleware;
-  }
-}
-export const route = new Router();