@stacksjs/router 0.58.58 → 0.58.60

package/dist/index.js

@@ -77,7 +77,60 @@ var normalizeString = function(path, allowAboveRoot) {
   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 = "";
@@ -99,16 +152,462 @@ var resolve = function(...arguments_) {
 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)
+  };
+};
 // /home/runner/work/stacks/stacks/storage/framework/core/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 buddyPath(path2, options) {
+  const absolutePath = corePath(`buddy/${path2 || ""}`);
+  if (options?.relative)
+    return relative(process2.cwd(), absolutePath);
+  return absolutePath;
+}
+function runtimePath(path2) {
+  return frameworkPath(`buddy/${path2 || ""}`);
+}
+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 commandsPath(path2) {
+  return appPath(`Commands/${path2 || ""}`);
+}
+function componentsPath(path2) {
+  return resourcesPath(`components/${path2 || ""}`);
+}
+function configPath(path2) {
+  return corePath(`config/${path2 || ""}`);
+}
+function corePath(path2) {
+  return frameworkPath(`core/${path2 || ""}`);
+}
+function customElementsDataPath() {
+  return frameworkPath("core/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, options) {
+  const absolutePath = projectStoragePath(`framework/${path2 || ""}`);
+  if (options?.relative)
+    return relative(options.cwd || process2.cwd(), absolutePath);
+  return absolutePath;
+}
+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 layoutsPath(path2, options) {
+  const absolutePath = resourcesPath(`layouts/${path2 || ""}`);
+  if (options?.relative)
+    return relative(process2.cwd(), absolutePath);
+  return absolutePath;
+}
+function libraryEntryPath(type) {
+  return libsEntriesPath(`${type}.ts`);
+}
+function lintPath(path2) {
+  return corePath(`lint/${path2 || ""}`);
+}
+function listenersPath(path2) {
+  return appPath(`Listeners/${path2 || ""}`);
+}
+function jobsPath(path2) {
+  return appPath(`Jobs/${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(`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,
+  buddyPath,
+  buildEnginePath,
+  libsEntriesPath,
+  buildPath,
+  cachePath,
+  chatPath,
+  cliPath,
+  cloudPath,
+  collectionsPath,
+  commandsPath,
+  componentsPath,
+  configPath,
+  projectConfigPath,
+  corePath,
+  customElementsDataPath,
+  databasePath,
+  datetimePath,
+  developmentPath,
+  desktopPath,
+  docsPath,
+  dnsPath,
+  emailPath,
+  enumsPath,
+  errorHandlingPath,
+  eventsPath,
+  coreEnvPath,
+  healthPath,
+  examplesPath,
+  fakerPath,
+  frameworkPath,
+  storagePath,
+  functionsPath,
+  gitPath,
+  langPath,
+  layoutsPath,
+  libsPath,
+  libraryEntryPath,
+  lintPath,
+  listenersPath,
+  loggingPath,
+  jobsPath,
+  modulesPath,
+  ormPath,
+  objectsPath,
+  onboardingPath,
+  notificationsPath,
+  packageJsonPath,
+  viewsPath,
+  pathPath,
+  paymentsPath,
+  projectPath,
+  projectStoragePath,
+  publicPath,
+  pushPath,
+  queryBuilderPath,
+  queuePath,
+  realtimePath,
+  resourcesPath,
+  replPath,
+  routerPath,
+  routesPath,
+  runtimePath,
+  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) {
@@ -281,32 +780,36 @@ class Router {
       paramNames: []
     });
   }
-  get(path4, callback) {
-    this.addRoute("GET", path4, callback, 200);
+  async get(path5, callback) {
+    if (typeof callback === "string") {
+      const actionModule = await import(path2.actionsPath(`${callback}.ts`));
+      callback = actionModule.default.handle;
+    }
+    this.addRoute("GET", path5, callback, 200);
     return this;
   }
-  post(path4, callback) {
-    this.addRoute("POST", path4, callback, 201);
+  post(path5, callback) {
+    this.addRoute("POST", path5, callback, 201);
     return this;
   }
-  view(path4, callback) {
-    this.addRoute("GET", path4, callback, 200);
+  view(path5, callback) {
+    this.addRoute("GET", path5, callback, 200);
     return this;
   }
-  redirect(path4, callback, _status) {
-    this.addRoute("GET", path4, callback, 302);
+  redirect(path5, callback, _status) {
+    this.addRoute("GET", path5, callback, 302);
     return this;
   }
-  delete(path4, callback) {
-    this.addRoute("DELETE", path4, callback, 204);
+  delete(path5, callback) {
+    this.addRoute("DELETE", path5, callback, 204);
     return this;
   }
-  patch(path4, callback) {
-    this.addRoute("PATCH", path4, callback, 202);
+  patch(path5, callback) {
+    this.addRoute("PATCH", path5, callback, 202);
     return this;
   }
-  put(path4, callback) {
-    this.addRoute("PUT", path4, callback, 202);
+  put(path5, callback) {
+    this.addRoute("PUT", path5, callback, 202);
     return this;
   }
   group(options, callback) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/router",
   "type": "module",
-  "version": "0.58.58",
+  "version": "0.58.60",
   "description": "The Stacks framework router.",
   "author": "Chris Breuer",
   "license": "MIT",

package/src/router.ts

@@ -1,8 +1,8 @@
 import type { RedirectCode, Route, RouteGroupOptions, StatusCode } from '@stacksjs/types'
-import { projectPath } from '@stacksjs/path'
+import { path as p, projectPath } from '@stacksjs/path'
 
 export interface RouterInterface {
-  get: (url: Route['url'], callback: Route['callback']) => this
+  get: (url: Route['url'], callback: Route['callback']) => Promise<this>
   post: (url: Route['url'], callback: Route['callback']) => this
   view: (url: Route['url'], callback: Route['callback']) => this
   redirect: (url: Route['url'], callback: Route['callback'], status?: RedirectCode) => this
@@ -46,7 +46,14 @@ export class Router implements RouterInterface {
     })
   }
 
-  public get(path: Route['url'], callback: Route['callback']): this {
+  public async get(path: Route['url'], callback: Route['callback']): Promise<this> {
+    // check if callback is a string and if it is, then import that module path and use the default.handle function as the callback
+    if (typeof callback === 'string') {
+      // import the module and use the default.handle function as the callback
+      const actionModule = await import(p.actionsPath(`${callback}.ts`))
+      callback = actionModule.default.handle
+    }
+
     this.addRoute('GET', path, callback, 200)
     return this
   }