@marko/run 0.1.1 → 0.1.3

package/dist/adapter/index.cjs

@@ -36,6 +36,7 @@ var import_url = require("url");
 
 // src/adapter/dev-server.ts
 var import_vite = require("vite");
+var import_strip_ansi = __toESM(require("strip-ansi"), 1);
 function createViteDevMiddleware(devServer, load, factory) {
   let value;
   let middleware;
@@ -51,7 +52,7 @@ function createViteDevMiddleware(devServer, load, factory) {
       res.statusCode = 500;
       if (err instanceof Error) {
         devServer.ssrFixStacktrace(err);
-        res.end(err.stack);
+        res.end(err.stack && (0, import_strip_ansi.default)(err.stack));
       } else {
         res.end();
       }

package/dist/adapter/index.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from "url";
 
 // src/adapter/dev-server.ts
 import { createServer } from "vite";
+import stripAnsi from "strip-ansi";
 function createViteDevMiddleware(devServer, load, factory) {
   let value;
   let middleware;
@@ -19,7 +20,7 @@ function createViteDevMiddleware(devServer, load, factory) {
       res.statusCode = 500;
       if (err instanceof Error) {
         devServer.ssrFixStacktrace(err);
-        res.end(err.stack);
+        res.end(err.stack && stripAnsi(err.stack));
       } else {
         res.end();
       }

package/dist/adapter/middleware.d.ts

@@ -20,7 +20,7 @@ export interface NodePlatformInfo {
     setCookie(cookie: string): void;
 }
 /** Connect/Express style request listener/middleware */
-export declare type NodeMiddleware = (req: IncomingMessage, res: ServerResponse & {
+export type NodeMiddleware = (req: IncomingMessage, res: ServerResponse & {
     flush?: () => void;
 }, next?: () => void) => void;
 /** Adapter options */

package/dist/cli/default.config.mjs

@@ -1,7 +1,6 @@
 import { defineConfig } from "vite";
 import marko from "@marko/run/vite";
-import nodeAdapter from "@marko/run/adapter";
 
 export default defineConfig({
-  plugins: [marko({ adapter: nodeAdapter() })]
+  plugins: [marko()]
 });

package/dist/cli/index.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import path from "path";
-import fs2 from "fs";
-import { fileURLToPath } from "url";
+import path3 from "path";
+import fs4 from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { build as viteBuild, resolveConfig } from "vite";
 import sade from "sade";
 
@@ -91,25 +91,124 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-// src/cli/index.ts
+// src/vite/plugin.ts
+import path2 from "path";
+import crypto from "crypto";
+import fs3 from "fs";
+import glob from "glob";
+import { mergeConfig, resolvePackageData } from "vite";
+import markoVitePlugin, { FileStore } from "@marko/vite";
+
+// src/vite/constants.ts
+var virtualFilePrefix = "virtual:marko-run";
+var virtualRoutesPrefix = `${virtualFilePrefix}/routes`;
+var virtualRuntimePrefix = `${virtualFilePrefix}/internal`;
+var RoutableFileTypes = {
+  Page: "page",
+  Layout: "layout",
+  Handler: "handler",
+  Middleware: "middleware",
+  Meta: "meta",
+  NotFound: "404",
+  Error: "500"
+};
+
+// src/vite/routes/builder.ts
+var markoFiles = `(${RoutableFileTypes.Layout}|${RoutableFileTypes.Page}|${RoutableFileTypes.NotFound}|${RoutableFileTypes.Error})\\.(?:.*\\.)?(marko)`;
+var nonMarkoFiles = `(${RoutableFileTypes.Middleware}|${RoutableFileTypes.Handler}|${RoutableFileTypes.Meta})\\.(?:.*\\.)?(.+)`;
+var routeableFileRegex = new RegExp(
+  `^[+](?:${markoFiles}|${nonMarkoFiles})$`,
+  "i"
+);
+
+// src/vite/routes/walk.ts
+import fs2 from "fs";
+import path from "path";
+
+// src/vite/utils/ast.ts
+import * as t from "@babel/types";
+
+// src/vite/utils/log.ts
+import Table from "cli-table3";
+import kleur from "kleur";
+import { gzipSizeSync } from "gzip-size";
+import format from "human-format";
+var HttpVerbColors = {
+  get: kleur.green,
+  post: kleur.magenta,
+  put: kleur.cyan,
+  delete: kleur.red,
+  other: kleur.white
+};
+
+// src/vite/plugin.ts
+import { fileURLToPath } from "url";
 var __dirname = fileURLToPath(new URL(".", import.meta.url));
+var POSIX_SEP = "/";
+var WINDOWS_SEP = "\\";
+var normalizePath = path2.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
+async function resolveAdapter(root, options, log) {
+  const { adapter } = options;
+  if (adapter !== void 0) {
+    return adapter;
+  }
+  const pkg = resolvePackageData(".", root);
+  if (pkg) {
+    const dependecies = { ...pkg.data.dependecies, ...pkg.data.devDependencies };
+    for (const name of Object.keys(dependecies)) {
+      if (name.startsWith("@marko/run-adapter") || name.indexOf("marko-run-adapter") !== -1) {
+        try {
+          const module2 = await import(name);
+          log && console.log(`Using adapter ${name} listed in your package.json dependecies`);
+          return module2.default();
+        } catch (err) {
+          log && console.warn(`Attempt to use package '${name}' failed`, err);
+        }
+      }
+    }
+  }
+  const defaultAdapter = "@marko/run/adapter";
+  const module = await import(defaultAdapter);
+  log && console.log("Using default adapter");
+  return module.default();
+}
+
+// src/cli/index.ts
+var __dirname2 = fileURLToPath2(new URL(".", import.meta.url));
 var cwd = process.cwd();
 var defaultPort = +process.env.PORT || 3e3;
 var defaultConfigFileBases = ["serve.config", "vite.config"];
 var defaultConfigFileExts = [".js", ".cjs", ".mjs", ".ts", ".mts"];
-var prog = sade("marko-run").version("0.0.1").option("-c, --config", `Provide path to a Vite config file (by default looks for a file starting with ${defaultConfigFileBases.join(" or ")} with one of these extensions: ${defaultConfigFileExts.join(", ")})`).option("-e, --env", "Provide path to a dotenv file");
-prog.command("preview [entry]").describe("Start a production-like server for already-built app files").option("-o, --output", "Directory to serve files from, and write asset files to if `--build` (default: )").option("-p, --port", "Port the server should listen on (defaults: `$PORT` env variable or 3000)").option("-f, --file", "Output file to start").action(async (entry, opts) => {
+var prog = sade("marko-run").version("0.0.1").option(
+  "-c, --config",
+  `Provide path to a Vite config file (by default looks for a file starting with ${defaultConfigFileBases.join(
+    " or "
+  )} with one of these extensions: ${defaultConfigFileExts.join(", ")})`
+).option("-e, --env", "Provide path to a dotenv file");
+prog.command("preview [entry]").describe("Start a production-like server for already-built app files").option(
+  "-o, --output",
+  "Directory to serve files from, and write asset files to if `--build` (default: )"
+).option(
+  "-p, --port",
+  "Port the server should listen on (defaults: `$PORT` env variable or 3000)"
+).option("-f, --file", "Output file to start").action(async (entry, opts) => {
   process.env.NODE_ENV = "production";
   const config2 = await getViteConfig(cwd, opts.config);
   await build(entry, config2, opts.output, false, opts.env);
   await preview(opts.entry, config2, opts.port, opts.output, opts.env);
 });
-prog.command("dev [entry]", "", { default: true }).describe("Start development server in watch mode").option("-p, --port", "Port the dev server should listen on (defaults: 'preview.port' in config, or `$PORT` env variable, or 3000)").example("dev --config vite.config.js").action(async (entry, opts) => {
+prog.command("dev [entry]", "", { default: true }).describe("Start development server in watch mode").option(
+  "-p, --port",
+  "Port the dev server should listen on (defaults: 'preview.port' in config, or `$PORT` env variable, or 3000)"
+).example("dev --config vite.config.js").action(async (entry, opts) => {
   const cmd = opts._.length ? `${entry} ${opts._.join(" ")}` : entry ? `node ${entry}` : void 0;
   const config2 = await getViteConfig(cwd, opts.config);
   await dev(cmd, config2, opts.port, opts.env);
 });
-prog.command("build [entry]").describe("Build the application (without serving it)").option("-o, --output", "Directory to write built files (default: 'build.outDir' in Vite config)").option("--skip-client", "Skip the client-side build").example("build --config vite.config.js").action(async (entry, opts) => {
+prog.command("build [entry]").describe("Build the application (without serving it)").option(
+  "-o, --output",
+  "Directory to write built files (default: 'build.outDir' in Vite config)"
+).option("--skip-client", "Skip the client-side build").example("build --config vite.config.js").action(async (entry, opts) => {
   process.env.NODE_ENV = "production";
   const config2 = await getViteConfig(cwd, opts.config);
   await build(entry, config2, opts.ouput, opts["skip-client"], opts.env);
@@ -117,46 +216,48 @@ prog.command("build [entry]").describe("Build the application (without serving i
 prog.parse(process.argv);
 async function preview(entry, configFile, port, outDir, envFile) {
   const resolvedConfig = await resolveConfig(
-    { root: cwd, configFile, build: { outDir } },
+    { root: cwd, configFile, logLevel: "silent", build: { outDir } },
     "serve"
   );
   if (port === void 0) {
     port = resolvedConfig.preview.port ?? defaultPort;
   }
-  const adapter = await resolveAdapter(resolvedConfig);
+  const adapter = await resolveAdapter2(resolvedConfig);
   if (!adapter) {
     throw new Error("No adapter specified for 'serve' command");
   } else if (!adapter.startPreview) {
     throw new Error(`Adapter ${adapter.name} does not support 'serve' command`);
   }
-  const dir = path.resolve(cwd, resolvedConfig.build.outDir);
-  const entryFile = entry ? path.join(dir, entry) : await findFileWithExt(dir, "index", [".mjs", ".js"]);
+  const dir = path3.resolve(cwd, resolvedConfig.build.outDir);
+  const entryFile = entry ? path3.join(dir, entry) : await findFileWithExt(dir, "index", [".mjs", ".js"]);
   if (envFile) {
-    envFile = path.resolve(cwd, envFile);
+    envFile = path3.resolve(cwd, envFile);
   }
   await adapter.startPreview(dir, entryFile, port, envFile);
 }
 async function dev(cmd, configFile, port, envFile) {
   const resolvedConfig = await resolveConfig(
-    { root: cwd, configFile },
+    { root: cwd, configFile, logLevel: "silent" },
     "build"
   );
   if (port === void 0) {
     port = resolvedConfig.preview.port ?? defaultPort;
   }
   if (envFile) {
-    envFile = path.resolve(cwd, envFile);
+    envFile = path3.resolve(cwd, envFile);
   }
   if (cmd) {
     await spawnServer(cmd, port, envFile);
   } else {
-    const adapter = await resolveAdapter(resolvedConfig);
+    const adapter = await resolveAdapter2(resolvedConfig);
     if (!adapter) {
       throw new Error(
         "No adapter specified for 'dev' command without custom target"
       );
     } else if (!adapter.startDev) {
-      throw new Error(`Adapter '${adapter.name}' does not support 'serve' command`);
+      throw new Error(
+        `Adapter '${adapter.name}' does not support 'serve' command`
+      );
     } else {
       await adapter.startDev(configFile, port, envFile);
     }
@@ -165,10 +266,10 @@ async function dev(cmd, configFile, port, envFile) {
 async function build(entry, configFile, outDir, skipClient = false, envFile) {
   var _a;
   const resolvedConfig = await resolveConfig(
-    { root: cwd, configFile },
+    { root: cwd, configFile, logLevel: "silent" },
     "build"
   );
-  const adapter = await resolveAdapter(resolvedConfig);
+  const adapter = await resolveAdapter2(resolvedConfig);
   if (!adapter) {
     throw new Error("No adapter specified for build command without entry");
   }
@@ -181,7 +282,7 @@ async function build(entry, configFile, outDir, skipClient = false, envFile) {
     }
   }
   if (envFile) {
-    envFile = path.resolve(cwd, envFile);
+    envFile = path3.resolve(cwd, envFile);
   }
   let buildConfig = {
     root: cwd,
@@ -222,8 +323,8 @@ async function build(entry, configFile, outDir, skipClient = false, envFile) {
 }
 function findFileWithExt(dir, base, extensions = defaultConfigFileExts) {
   for (const ext of extensions) {
-    const filePath = path.join(dir, base + ext);
-    if (fs2.existsSync(filePath)) {
+    const filePath = path3.join(dir, base + ext);
+    if (fs4.existsSync(filePath)) {
       return filePath;
     }
   }
@@ -231,8 +332,8 @@ function findFileWithExt(dir, base, extensions = defaultConfigFileExts) {
 }
 async function getViteConfig(dir, configFile, bases = defaultConfigFileBases) {
   if (configFile) {
-    const configFilePath = path.join(dir, configFile);
-    if (!fs2.existsSync(configFilePath)) {
+    const configFilePath = path3.join(dir, configFile);
+    if (!fs4.existsSync(configFilePath)) {
       throw new Error(`No config file found at '${configFilePath}'`);
     }
     return configFile;
@@ -243,12 +344,12 @@ async function getViteConfig(dir, configFile, bases = defaultConfigFileBases) {
       return configFile;
     }
   }
-  return path.join(__dirname, "default.config.mjs");
+  return path3.join(__dirname2, "default.config.mjs");
 }
-async function resolveAdapter(config2) {
+async function resolveAdapter2(config2) {
   const options = getExternalPluginOptions(config2);
   if (!options) {
-    throw new Error("Unable to resolve @marko/serve options");
+    throw new Error("Unable to resolve @marko/run options");
   }
-  return options.adapter;
+  return resolveAdapter(config2.root, options);
 }

package/dist/components/src-attributes-transformer.cjs

@@ -0,0 +1,122 @@
+"use strict";
+
+const markoUtils = require("@marko/babel-utils");
+const attrTags = {
+  src: [
+    "audio",
+    "embed",
+    "iframe",
+    "img",
+    "input",
+    "script",
+    "source",
+    "track",
+    "video"
+  ],
+  href: ["a", "area", "link"],
+  data: ["object"],
+  poster: ["video"],
+  srcset: ["img"],
+  //something else needs to happen here
+  background: ["body"]
+};
+const tagAttrs = Object.keys(attrTags).reduce((tagAttrs, attrName) => {
+  attrTags[attrName].forEach(tagName => {
+    tagAttrs[tagName] = tagAttrs[tagName] || {};
+    tagAttrs[tagName][attrName] = true;
+  });
+  return tagAttrs;
+}, {});
+
+module.exports = function(a, b) {
+  if (a.hub) {
+    return transformMarko5(a, b);
+  }
+
+  return transformMarko4(a, b);
+};
+
+function transformMarko5(path) {
+  if (!path.get("name").isStringLiteral()) {
+    return;
+  }
+
+  const tagName = path.get("name.value").node;
+  const checkAttrs = tagAttrs[tagName];
+  if (!checkAttrs) {
+    return;
+  }
+
+  path.get("attributes").forEach(attr => {
+    if (!checkAttrs[attr.get("name").node]) {
+      return;
+    }
+
+    const { confident, value } = attr.get("value").evaluate();
+
+    if (!confident || !isAssetPath(value)) {
+      return;
+    }
+
+    attr.set("value", markoUtils.importDefault(path.hub.file, value, "asset"));
+  });
+}
+
+function transformMarko4(el, context) {
+  const checkAttrs = tagAttrs[el.tagName];
+  if (!checkAttrs) {
+    return;
+  }
+
+  el.attributes.forEach(attr => {
+    if (!checkAttrs[attr.name]) {
+      return;
+    }
+
+    const walker = context.createWalker({
+      enter: node => {
+        switch (node.type) {
+          case "ArrayExpression":
+          case "ObjectExpression":
+          case "Property":
+          case "LogicalExpression":
+            return;
+          case "ConditionalExpression":
+            node.consequent = walker.walk(node.consequent);
+            node.alternate = walker.walk(node.alternate);
+            walker.skip();
+            break;
+          case "Literal": {
+            const { value } = node;
+
+            if (!isAssetPath(value)) {
+              return;
+            }
+
+            context.assetCount = context.assetCount || 0;
+            const varName = `__src_asset_${context.assetCount++}__`;
+            const tagString = `import ${varName} from ${JSON.stringify(value)}`;
+            const importTag = context.createNodeForEl("import");
+            importTag.tagString = tagString;
+            context.root.prependChild(importTag);
+            walker.replace(context.builder.identifier(varName));
+            break;
+          }
+          default:
+            walker.skip();
+            break;
+        }
+      }
+    });
+
+    attr.value = walker.walk(attr.value);
+  });
+}
+
+function isAssetPath(relativePath) {
+  if (typeof relativePath !== "string") return false;
+  if (relativePath[0] === "/") return false; // Ignore absolute paths.
+  if (!/\.[^.]+$/.test(relativePath)) return false; // Ignore paths without a file extension.
+  if (/^[a-z]{2,}:/i.test(relativePath)) return false; // Ignore paths with a protocol.
+  return true;
+}

package/dist/runtime/index.d.ts

@@ -1,12 +1,5 @@
 import type { HandlerLike, ParamsObject, Route as AnyRoute, Context as AnyContext } from "./types";
 declare global {
-    namespace Marko {
-        interface Global extends MarkoRun.Context {
-        }
-        interface Out {
-            global: Global;
-        }
-    }
     namespace MarkoRun {
         const NotHandled: unique symbol;
         const NotMatched: unique symbol;
@@ -18,4 +11,4 @@ declare global {
         function route<Params extends ParamsObject = {}, Meta = unknown>(handler: Handler<Params, Meta>): typeof handler;
     }
 }
-export type { Fetch, HandlerLike, InputObject, Invoke, Match, NextFunction, PathTemplate, Route, Context, ContextExtensions, RouteHandler, RouteWithHandler, RuntimeModule, ValidateHref, ValidatePath, } from "./types";
+export type { Context, ContextExtensions, Fetch, HandlerLike, InputObject, Invoke, Match, NextFunction, ParamsObject, PathTemplate, Route, RouteHandler, RouteWithHandler, RuntimeModule, ValidateHref, ValidatePath, } from "./types";

package/dist/runtime/internal.cjs

@@ -24,7 +24,7 @@ __export(internal_exports, {
   NotMatched: () => NotMatched,
   call: () => call,
   compose: () => compose,
-  createInput: () => createInput,
+  createContext: () => createContext,
   noContent: () => noContent,
   normalize: () => normalize,
   notHandled: () => notHandled,
@@ -48,14 +48,35 @@ globalThis.MarkoRun ?? (globalThis.MarkoRun = {
     return handler;
   }
 });
-function createInput(context) {
-  let existing;
-  return (data) => {
-    existing ?? (existing = {
-      $global: context
-    });
-    return data ? Object.assign(existing, data) : existing;
+var serializedGlobals = { params: true, url: true };
+function createContext(route, request, platform, url = new URL(request.url)) {
+  const context = route ? {
+    request,
+    url,
+    platform,
+    meta: route.meta,
+    params: route.params,
+    route: route.path,
+    serializedGlobals
+  } : {
+    request,
+    url,
+    platform,
+    meta: {},
+    params: {},
+    route: "",
+    serializedGlobals
   };
+  let input;
+  return [
+    context,
+    (data) => {
+      input ?? (input = {
+        $global: context
+      });
+      return data ? Object.assign(input, data) : input;
+    }
+  ];
 }
 async function call(handler, next, context) {
   let response;
@@ -151,7 +172,7 @@ function notMatched() {
   NotMatched,
   call,
   compose,
-  createInput,
+  createContext,
   noContent,
   normalize,
   notHandled,

package/dist/runtime/internal.d.ts

@@ -2,7 +2,7 @@ import type { InputObject, NextFunction, Route, Context, RouteHandler } from "./
 export declare function pageResponse(template: any, input: Record<PropertyKey, unknown>): Response;
 export declare const NotHandled: typeof MarkoRun.NotHandled;
 export declare const NotMatched: typeof MarkoRun.NotMatched;
-export declare function createInput(context: Context): (data: InputObject) => InputObject;
+export declare function createContext<Platform, TRoute extends Route>(route: TRoute | undefined, request: Request, platform: Platform, url?: URL): [Context, (data?: InputObject) => InputObject];
 export declare function call(handler: RouteHandler<Route>, next: NextFunction, context: Context): Promise<Response>;
 export declare function compose(handlers: RouteHandler[]): RouteHandler;
 export declare function normalize(obj: RouteHandler | RouteHandler[] | Promise<RouteHandler | RouteHandler[]>): RouteHandler;

package/dist/runtime/internal.js

@@ -15,14 +15,35 @@ globalThis.MarkoRun ?? (globalThis.MarkoRun = {
     return handler;
   }
 });
-function createInput(context) {
-  let existing;
-  return (data) => {
-    existing ?? (existing = {
-      $global: context
-    });
-    return data ? Object.assign(existing, data) : existing;
+var serializedGlobals = { params: true, url: true };
+function createContext(route, request, platform, url = new URL(request.url)) {
+  const context = route ? {
+    request,
+    url,
+    platform,
+    meta: route.meta,
+    params: route.params,
+    route: route.path,
+    serializedGlobals
+  } : {
+    request,
+    url,
+    platform,
+    meta: {},
+    params: {},
+    route: "",
+    serializedGlobals
   };
+  let input;
+  return [
+    context,
+    (data) => {
+      input ?? (input = {
+        $global: context
+      });
+      return data ? Object.assign(input, data) : input;
+    }
+  ];
 }
 async function call(handler, next, context) {
   let response;
@@ -117,7 +138,7 @@ export {
   NotMatched,
   call,
   compose,
-  createInput,
+  createContext,
   noContent,
   normalize,
   notHandled,

package/dist/runtime/types.d.ts

@@ -1,23 +1,21 @@
-declare type Awaitable<T> = Promise<T> | T;
-declare type OneOrMany<T> = T | T[];
-declare type Combine<T> = T extends object ? {
-    [P in keyof T]: T[P];
-} : T;
+type Awaitable<T> = Promise<T> | T;
+type OneOrMany<T> = T | T[];
 export interface ContextExtensions {
 }
-export declare type ParamsObject = Record<string, string>;
-export declare type InputObject = Record<PropertyKey, any>;
-export declare type Context<Platform = unknown, TRoute extends Route = Route> = TRoute extends any ? Combine<ContextExtensions & Readonly<{
-    url: URL;
-    request: Request;
-    route: TRoute["path"];
-    params: TRoute["params"];
-    meta: TRoute["meta"];
-    platform: Platform;
-}>> : never;
-export declare type NextFunction = () => Awaitable<Response>;
-export declare type HandlerLike<TRoute extends Route = Route> = Awaitable<OneOrMany<RouteHandler<TRoute>>>;
-export declare type RouteHandler<TRoute extends Route = Route> = (context: Context<unknown, TRoute>, next: NextFunction) => Awaitable<Response | null | void>;
+export type Context<Platform = unknown, TRoute extends Route = Route> = ContextExtensions & {
+    readonly url: URL;
+    readonly request: Request;
+    readonly route: TRoute["path"];
+    readonly params: TRoute["params"];
+    readonly meta: TRoute["meta"];
+    readonly platform: Platform;
+    readonly serializedGlobals: Record<string, boolean>;
+};
+export type ParamsObject = Record<string, string>;
+export type InputObject = Record<PropertyKey, any>;
+export type NextFunction = () => Awaitable<Response>;
+export type HandlerLike<TRoute extends Route = Route> = Awaitable<OneOrMany<RouteHandler<TRoute>>>;
+export type RouteHandler<TRoute extends Route = Route> = (context: Context<unknown, TRoute>, next: NextFunction) => Awaitable<Response | null | void>;
 export interface Route<Params extends ParamsObject = {}, Meta = unknown, Path extends string = string> {
     path: Path;
     params: Params;
@@ -26,20 +24,20 @@ export interface Route<Params extends ParamsObject = {}, Meta = unknown, Path ex
 export interface RouteWithHandler<Params extends ParamsObject = {}, Meta = unknown, Path extends string = string> extends Route<Params, Meta, Path> {
     handler: RouteHandler<this>;
 }
-export declare type Fetch<Platform = unknown> = (request: Request, platform: Platform) => Promise<Response | void>;
-export declare type Match = (method: string, pathname: string) => RouteWithHandler | null;
-export declare type Invoke = <Platform = unknown>(route: RouteWithHandler | null, request: Request, platform: Platform) => Promise<Response | void>;
+export type Fetch<Platform = unknown> = (request: Request, platform: Platform) => Promise<Response | void>;
+export type Match = (method: string, pathname: string) => RouteWithHandler | null;
+export type Invoke = <Platform = unknown>(route: RouteWithHandler | null, request: Request, platform: Platform) => Promise<Response | void>;
 export interface RuntimeModule {
     fetch: <Platform = unknown>(request: Request, platform: Platform) => Promise<Response | void>;
     match: (method: string, pathname: string) => RouteWithHandler | null;
     invoke: <Platform = unknown>(route: RouteWithHandler | null, request: Request, platform: Platform) => Promise<Response | void>;
 }
-declare type Member<T, U> = T extends T ? (U extends T ? T : never) : never;
-declare type Segments<T extends string, Acc extends string[] = []> = T extends "" ? Acc : T extends `${infer Left}/${infer Rest}` ? Segments<Rest, [...Acc, Left]> : [...Acc, T];
-declare type GTE<A extends any[], B extends any[]> = A["length"] extends B["length"] ? 1 : A extends [infer _Ha, ...infer Ta] ? B extends [infer _Hb, ...infer Tb] ? GTE<Ta, Tb> : 1 : 0;
-declare type MatchSegments<A extends string, B extends string> = A extends `${infer P}/${string}*` ? 1 extends GTE<Segments<B>, Segments<P>> ? `${P}/${string}` : never : Segments<B>["length"] extends Segments<A>["length"] ? A : never;
-declare type PathPattern<T extends string> = T extends `${infer Left}/\${${string}}/${infer Rest}` ? PathPattern<`${Left}/${string}/${Rest}`> : T extends `${infer Left}/\${...${string}}` ? PathPattern<`${Left}/${string}*`> : T extends `${infer Left}/\${${string}}` ? PathPattern<`${Left}/${string}`> : T;
-export declare type PathTemplate<Path extends string> = Path extends `${infer Left}/\${${string}}/${infer Rest}` ? PathTemplate<`${Left}/${string}/${Rest}`> : Path extends `${infer Left}/\${${string}}` ? PathTemplate<`${Left}/${string}`> : Path;
-export declare type ValidatePath<Paths extends string, Path extends string> = Paths | (Path extends `/${string}` ? MatchSegments<Member<PathPattern<Paths>, Path>, Path> : Path);
-export declare type ValidateHref<Paths extends string, Href extends string> = Href extends `${infer P}#${infer H}?${infer Q}` ? `${ValidatePath<Paths, P>}#${H}?${Q}` : Href extends `${infer P}?${infer Q}` ? `${ValidatePath<Paths, P>}?${Q}` : Href extends `${infer P}#${infer H}` ? `${ValidatePath<Paths, P>}#${H}` : ValidatePath<Paths, Href>;
+type Member<T, U> = T extends T ? (U extends T ? T : never) : never;
+type Segments<T extends string, Acc extends string[] = []> = T extends "" ? Acc : T extends `${infer Left}/${infer Rest}` ? Segments<Rest, [...Acc, Left]> : [...Acc, T];
+type GTE<A extends any[], B extends any[]> = A["length"] extends B["length"] ? 1 : A extends [infer _Ha, ...infer Ta] ? B extends [infer _Hb, ...infer Tb] ? GTE<Ta, Tb> : 1 : 0;
+type MatchSegments<A extends string, B extends string> = A extends `${infer P}/${string}*` ? 1 extends GTE<Segments<B>, Segments<P>> ? `${P}/${string}` : never : Segments<B>["length"] extends Segments<A>["length"] ? A : never;
+type PathPattern<T extends string> = T extends `${infer Left}/\${${string}}/${infer Rest}` ? PathPattern<`${Left}/${string}/${Rest}`> : T extends `${infer Left}/\${...${string}}` ? PathPattern<`${Left}/${string}*`> : T extends `${infer Left}/\${${string}}` ? PathPattern<`${Left}/${string}`> : T;
+export type PathTemplate<Path extends string> = Path extends `${infer Left}/\${${string}}/${infer Rest}` ? PathTemplate<`${Left}/${string}/${Rest}`> : Path extends `${infer Left}/\${${string}}` ? PathTemplate<`${Left}/${string}`> : Path;
+export type ValidatePath<Paths extends string, Path extends string> = Paths | (Path extends `/${string}` ? MatchSegments<Member<PathPattern<Paths>, Path>, Path> : Path);
+export type ValidateHref<Paths extends string, Href extends string> = Href extends `${infer P}#${infer H}?${infer Q}` ? `${ValidatePath<Paths, P>}#${H}?${Q}` : Href extends `${infer P}?${infer Q}` ? `${ValidatePath<Paths, P>}?${Q}` : Href extends `${infer P}#${infer H}` ? `${ValidatePath<Paths, P>}#${H}` : ValidatePath<Paths, Href>;
 export {};

package/dist/vite/codegen/index.d.ts

@@ -1,6 +1,6 @@
-import type { Route, BuiltRoutes, RoutableFile, RouterOptions } from "../types";
+import type { Adapter, Route, BuiltRoutes, RoutableFile, RouterOptions } from "../types";
 export declare function renderRouteTemplate(route: Route): string;
 export declare function renderRouteEntry(route: Route): string;
 export declare function renderRouter(routes: BuiltRoutes, options?: RouterOptions): string;
 export declare function renderMiddleware(middleware: RoutableFile[]): string;
-export declare function renderRouteTypeInfo(routes: BuiltRoutes, pathPrefix?: string, adapterTypes?: string): string;
+export declare function renderRouteTypeInfo(routes: BuiltRoutes, pathPrefix?: string, adapter?: Adapter | null): Promise<string>;