@marko/run 0.1.6 → 0.1.8

package/README.md

@@ -481,9 +481,25 @@ express()
 
 **`MarkoRun.Handler`** - Type that represents a handler function to be exported by a +handler or +middleware file
 
-**`MarkoRun.CurrentRoute`** - Type of the route's params and metadata
+**`MarkoRun.Route`** - Type of the route's params and metadata
 
-**`MarkoRun.CurrentContext`** - Type of the request context object in a handler and `out.global` in your Marko files
+**`MarkoRun.Context`** - Type of the request context object in a handler and `$global` in your Marko files. This type can be extended using TypeScript's module and interface merging by declaring a `Context` interface on the `@marko/run` module within your applcation code
+```ts
+declare module "@marko/run" {
+  interface Context {
+    customPropery: MyCustomThing // will be globally defined on MarkoRun.Context
+  }
+}
+```
+
+**`MarkoRun.Platform`** - Type of the platform object provided by the adapter in use. This interface can be extended in that same way as `Context` (see above) by declaring a `Platform` interface: 
+```ts
+declare module "@marko/run" {
+  interface Platform {
+    customPropery: MyCustomThing // will be globally defined on MarkoRun.Platform
+  }
+}
+```
 
 
 ### Generated Types
@@ -493,13 +509,13 @@ If a [TSConfig](https://www.typescriptlang.org/tsconfig) file is discovered in t
 These types are replaced with more specific versions per routable file:
 
 **`MarkoRun.Handler`**
-- Overrides context with specific MarkoRun.CurrentContext
+- Overrides context with specific MarkoRun.Context
 
-**`MarkoRun.CurrentRoute`**
+**`MarkoRun.Route`**
 - Adds specific parameters and meta types 
 - In middleware and layouts which are used in many routes, this type will be a union of all possible routes that the file will see
 
-**`MarkoRun.CurrentContext`**
+**`MarkoRun.Context`**
 - In middleware and layouts which are used in many routes, this type will be a union of all possible routes that the file will see.
 - When an adapter is used, it can provide types for the platform
 

package/dist/runtime/index.d.ts

@@ -1,15 +1,10 @@
-import type { HandlerLike, ParamsObject, Route as AnyRoute, Context as AnyContext, RuntimeModule } from "./types";
+import { NotHandled, NotMatched } from "./namespace";
+import { GetPaths, PostPaths, GetablePath, GetableHref, PostablePath, PostableHref, Platform, HandlerTypeFn, RuntimeModule, AnyRoute, AnyContext, AnyHandler } from "./types";
 declare global {
     var __marko_run__: RuntimeModule;
     namespace MarkoRun {
-        const NotHandled: unique symbol;
-        const NotMatched: unique symbol;
-        interface Route extends AnyRoute {
-        }
-        interface Context extends AnyContext {
-        }
-        type Handler<Params extends ParamsObject = {}, Meta = unknown> = HandlerLike<AnyRoute<Params, Meta, string>>;
-        function route<Params extends ParamsObject = {}, Meta = unknown>(handler: Handler<Params, Meta>): typeof handler;
+        export const route: HandlerTypeFn;
+        export { GetPaths, PostPaths, GetablePath, GetableHref, PostablePath, PostableHref, Platform, NotHandled, NotMatched, AnyRoute as Route, AnyContext as Context, AnyHandler as Handler, };
     }
 }
-export type { Context, ContextExtensions, Fetch, HandlerLike, InputObject, Invoke, Match, NextFunction, ParamsObject, PathTemplate, Route, RouteHandler, RouteWithHandler, RuntimeModule, ValidateHref, ValidatePath, } from "./types";
+export type { AppData, Context, DefineApp, Fetch, HandlerTypeFn, HandlerLike, InputObject, Invoke, Match, MultiRouteContext, NextFunction, ParamsObject, Platform, Route, Routes, RouteHandler, RouteWithHandler, RuntimeModule, } from "./types";

package/dist/runtime/internal.d.ts

@@ -1,9 +1,9 @@
-import type { InputObject, NextFunction, Route, Context, RouteHandler } from "./types";
+import type { InputObject, NextFunction, AnyRoute, Context, MultiRouteContext, RouteHandler, Platform } from "./types";
 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 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 createContext<TRoute extends AnyRoute>(route: TRoute | undefined, request: Request, platform: Platform, url?: URL): [Context<TRoute>, (data?: InputObject) => InputObject];
+export declare function call<TRoute extends AnyRoute>(handler: RouteHandler<TRoute>, next: NextFunction, context: MultiRouteContext<TRoute>): Promise<Response>;
 export declare function compose(handlers: RouteHandler[]): RouteHandler;
 export declare function normalize(obj: RouteHandler | RouteHandler[] | Promise<RouteHandler | RouteHandler[]>): RouteHandler;
 export declare function noContent(): Response;

package/dist/runtime/namespace.d.ts

@@ -0,0 +1,3 @@
+export declare const NotHandled: unique symbol;
+export declare const NotMatched: unique symbol;
+export type { GetPaths, PostPaths, GetablePath, GetableHref, PostablePath, PostableHref, Platform } from "./types";

package/dist/runtime/router.d.ts

@@ -1,3 +1,3 @@
-export declare const fetch: <Platform = unknown>(request: Request, platform: Platform) => Promise<void | Response>;
-export declare const match: (method: string, pathname: string) => import("./types").RouteWithHandler<{}, unknown, string> | null;
-export declare const invoke: <Platform = unknown>(route: import("./types").RouteWithHandler<{}, unknown, string> | null, request: Request, platform: Platform) => Promise<void | Response>;
+export declare const fetch: <TPlatform extends import("./types").Platform = import("./types").Platform>(request: Request, platform: TPlatform) => Promise<void | Response>;
+export declare const match: import("./types").Match;
+export declare const invoke: <TPlatform extends import("./types").Platform = import("./types").Platform>(route: import("./types").RouteWithHandler<import("./types").ParamsObject, unknown, string> | null, request: Request, platform: TPlatform) => Promise<void | Response>;

package/dist/runtime/types.d.ts

@@ -1,8 +1,9 @@
 type Awaitable<T> = Promise<T> | T;
 type OneOrMany<T> = T | T[];
-export interface ContextExtensions {
+type NoParams = {};
+export interface Platform {
 }
-export type Context<Platform = unknown, TRoute extends Route = Route> = ContextExtensions & {
+export interface Context<TRoute extends AnyRoute = AnyRoute> {
     readonly url: URL;
     readonly request: Request;
     readonly route: TRoute["path"];
@@ -10,34 +11,87 @@ export type Context<Platform = unknown, TRoute extends Route = Route> = ContextE
     readonly meta: TRoute["meta"];
     readonly platform: Platform;
     readonly serializedGlobals: Record<string, boolean>;
-};
+}
+export type MultiRouteContext<TRoute extends AnyRoute> = TRoute extends any ? Context<TRoute> : never;
 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> {
+export type HandlerLike<TRoute extends AnyRoute = AnyRoute> = Awaitable<OneOrMany<RouteHandler<TRoute>>>;
+export type RouteHandler<TRoute extends AnyRoute = AnyRoute> = (context: MultiRouteContext<TRoute>, next: NextFunction) => Awaitable<Response | null | void>;
+export interface Route<Params extends ParamsObject, Meta, Path extends string> {
     path: Path;
     params: Params;
     meta: Meta;
 }
-export interface RouteWithHandler<Params extends ParamsObject = {}, Meta = unknown, Path extends string = string> extends Route<Params, Meta, Path> {
+type DefineRoutes<T extends Record<string, {
+    meta?: unknown;
+}>> = {
+    [K in keyof T]: K extends string ? T[K] extends {
+        meta: infer Meta;
+    } ? Route<PathParams<K>, Meta, K> : Route<PathParams<K>, unknown, K> : never;
+};
+type DefinePaths<T extends Record<string, {
+    verb: unknown;
+}>, Verb extends "get" | "post"> = {
+    [K in keyof T]: K extends string ? T[K] extends {
+        verb: infer V;
+    } ? V extends Verb ? ConvertPath<K> : never : never : never;
+}[keyof T];
+export type DefineApp<T extends {
+    routes: Record<string, {
+        verb: "get" | "post";
+        meta?: unknown;
+    }>;
+}> = {
+    routes: DefineRoutes<T["routes"]>;
+    getPaths: DefinePaths<T["routes"], "get">;
+    postPaths: DefinePaths<T["routes"], "post">;
+};
+export interface RouteWithHandler<Params extends ParamsObject = ParamsObject, Meta = unknown, Path extends string = string> extends Route<Params, Meta, Path> {
     handler: RouteHandler<this>;
 }
-export type Fetch<Platform = unknown> = (request: Request, platform: Platform) => Promise<Response | void>;
+export type Fetch<TPlatform extends Platform = Platform> = (request: Request, platform: TPlatform) => 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 type Invoke<TPlatform extends Platform = Platform> = (route: RouteWithHandler | null, request: Request, platform: TPlatform) => 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>;
+    fetch<TPlatform extends Platform = Platform>(...args: Parameters<Fetch<TPlatform>>): ReturnType<Fetch<TPlatform>>;
+    match: Match;
+    invoke<TPlatform extends Platform = Platform>(...args: Parameters<Invoke<TPlatform>>): ReturnType<Invoke<TPlatform>>;
 }
 type Member<T, U> = T extends T ? (U extends T ? T : never) : never;
+type PathParamKeys<Path extends string> = Path extends `${infer _}:${infer Param}/${infer Rest}` ? [Param, ...PathParamKeys<Rest>] : Path extends `${infer _}:${infer Param}*` ? [Param] : Path extends `${infer _}:${infer Param}` ? [Param] : [];
+type PathParams<Path extends string, Keys extends string[] = PathParamKeys<Path>> = 0 extends Keys["length"] ? NoParams : {
+    [K in Keys[number]]: string;
+};
 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 type ConvertPath<Path extends string> = Path extends `${infer Left}/:${infer Param}/${infer Rest}` ? ConvertPath<`${Left}/\${${Param}}/${Rest}`> : Path extends `${infer Left}/:${infer Param}*` ? `${Left}/\${${Param}...}` : Path extends `${infer Left}/:${infer Param}` ? `${Left}/\${${Param}}` : Path;
+type ValidatePath<Paths extends string, Path extends string> = Paths | (Path extends `/${string}` ? MatchSegments<Member<PathPattern<Paths>, Path>, Path> : Path);
+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 interface AppData {
+}
+type HasAppData = AppData extends {
+    routes: any;
+} ? 1 : 0;
+type AnyParams = 0 extends HasAppData ? ParamsObject : never;
+type AnyMeta = 0 extends HasAppData ? unknown : never;
+export type Routes = AppData extends {
+    routes: infer T;
+} ? T : Record<string, Route<ParamsObject, unknown, string>>;
+export type AnyRoute = Routes[keyof Routes];
+export type AnyContext = MultiRouteContext<AnyRoute>;
+export type AnyHandler<Params extends AnyParams = AnyParams, Meta extends AnyMeta = AnyMeta> = 0 extends HasAppData ? HandlerLike<Route<Params, Meta, string>> : HandlerLike<AnyRoute>;
+export type HandlerTypeFn<THandler extends HandlerLike = AnyHandler> = 0 extends HasAppData ? <Params extends ParamsObject = ParamsObject, Meta = unknown>(handler: HandlerLike<Route<Params, Meta, string>>) => HandlerLike<Route<Params, Meta, string>> : (handler: THandler) => THandler;
+export type GetPaths = AppData extends {
+    getPaths: infer T;
+} ? T : string;
+export type PostPaths = AppData extends {
+    postPaths: infer T;
+} ? T : string;
+export type GetablePath<T extends string> = ValidatePath<GetPaths, T>;
+export type GetableHref<T extends string> = ValidateHref<GetPaths, T>;
+export type PostablePath<T extends string> = ValidatePath<PostPaths, T>;
+export type PostableHref<T extends string> = ValidateHref<PostPaths, T>;
 export {};

package/dist/vite/index.cjs

@@ -232,7 +232,7 @@ async function buildRoutes(walk, basePath) {
             });
           }
         }
-        pathStack.push(name.toLowerCase());
+        pathStack.push(name);
       }
       dirStack.push(name);
       isRoot = false;
@@ -680,9 +680,11 @@ function renderRouter(routes, options = {
       `import page${key} from '${virtualFilePrefix}/${markoRunFilePrefix}special__${key}.marko${serverEntryQuery}';`
     );
   }
-  writer.writeLines(`
+  writer.writeLines(
+    `
 globalThis.__marko_run__ = { match, fetch, invoke };
-    `).writeBlockStart(`export function match(method, pathname) {`).writeLines(
+    `
+  ).writeBlockStart(`export function match(method, pathname) {`).writeLines(
     `if (!pathname) {
     pathname = '/';
   } else if (pathname.charAt(0) !== '/') {
@@ -942,22 +944,13 @@ function renderParamsInfo(params, pathIndex) {
   }
   return result ? result + " }" : "{}";
 }
-function renderParamsInfoType(params) {
-  if (!params.length) {
-    return "{}";
-  }
-  let result = "{";
-  for (const { name } of params) {
-    result += ` ${wrapPropertyName(name)}: string;`;
-  }
-  return result + " }";
-}
 function renderMatch(verb, route, pathIndex) {
   var _a;
   const handler = `${verb}${route.index}`;
   const params = ((_a = route.params) == null ? void 0 : _a.length) ? renderParamsInfo(route.params, pathIndex) : "{}";
   const meta = route.meta ? `meta${route.index}` : "{}";
-  return `{ handler: ${handler}, params: ${params}, meta: ${meta} }`;
+  const path3 = pathToURLPatternString(route.path);
+  return `{ handler: ${handler}, params: ${params}, meta: ${meta}, path: '${path3}' }`;
 }
 function renderMiddleware(middleware) {
   const writer = createStringWriter();
@@ -994,76 +987,64 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
   Do NOT manually edit this file or your changes will be lost.
 */
 `,
-    `import type { HandlerLike, Route as AnyRoute, Context as AnyContext, ParamsObject, ValidatePath, ValidateHref } from "@marko/run";`
+    `import "@marko/run/namespace";`,
+    `import type Run from "@marko/run";`
   );
-  let platformType = "unknown";
+  const headWriter = writer.branch("head");
+  writer.writeLines("\n").writeBlockStart(`declare module "@marko/run" {`);
   if (adapter && adapter.typeInfo) {
-    platformType = await adapter.typeInfo((data) => writer.write(data));
-    writer.writeLines("");
-  }
-  writer.writeLines(`
-interface NoParams extends ParamsObject {}
-interface NoMeta {}
+    const platformType = await adapter.typeInfo(
+      (data) => headWriter.write(data)
+    );
+    if (platformType) {
+      writer.writeLines(`interface Platform extends ${platformType} {}
 `);
-  const pathsWriter = writer.branch("paths");
-  const routesWriter = writer.branch("types");
-  const serverWriter = writer.branch("server");
+    }
+  }
+  writer.writeBlockStart(`interface AppData extends Run.DefineApp<{`).writeBlockStart("routes: {");
+  const routesWriter = writer.branch("routes");
+  writer.writeBlockEnd("}").writeBlockEnd(`}> {}`).writeBlockEnd(`}`);
+  headWriter.join();
+  const moduleWriter = writer.branch("module");
   const middlewareRouteTypes = /* @__PURE__ */ new Map();
   const layoutRouteTypes = /* @__PURE__ */ new Map();
-  const getPaths = /* @__PURE__ */ new Set();
-  const postPaths = /* @__PURE__ */ new Set();
-  writeModuleDeclaration(serverWriter, void 0, void 0, platformType);
   for (const route of routes.list) {
-    const { meta, handler, params, middleware, page, layouts } = route;
-    const routeType = `Route${route.index}`;
-    const pathType = `\`${route.path.replace(
-      /\/\$(\$?)([^\/]*)/,
-      (_, catchAll, name) => {
-        name = decodeURIComponent(name);
-        return catchAll ? `/:${name || "rest"}*` : `/:${name}`;
-      }
-    )}\``;
-    const paramsType = (params == null ? void 0 : params.length) ? renderParamsInfoType(params) : "NoParams";
-    let metaType = "NoMeta";
+    const { meta, handler, middleware, page, layouts } = route;
+    const pathType = `${pathToURLPatternString(route.path)}`;
+    const routeType = `"${pathType}"`;
+    let verbType = "";
     if (page || handler) {
-      const isGet = page || ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.includes("get"));
-      const isPost = (_b = handler == null ? void 0 : handler.verbs) == null ? void 0 : _b.includes("post");
-      if (isGet || isPost) {
-        const path3 = route.path.replace(/\$(\$?)([^/]+)/g, (_, catchAll, name) => {
-          name = decodeURIComponent(name);
-          return catchAll ? `\${...${name}}` : `\${${name}}`;
-        });
-        const splatIndex = path3.indexOf("/${...");
-        if (splatIndex >= 0) {
-          const path22 = path3.slice(0, splatIndex) || "/";
-          isGet && getPaths.add(path22);
-          isPost && postPaths.add(path22);
-        }
-        isGet && getPaths.add(path3);
-        isPost && postPaths.add(path3);
+      const verbs = [];
+      if (page || ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.includes("get"))) {
+        verbs.push(`"get"`);
+      }
+      if ((_b = handler == null ? void 0 : handler.verbs) == null ? void 0 : _b.includes("post")) {
+        verbs.push(`"post"`);
       }
+      verbType = verbs.join(" | ");
     }
     if (meta) {
       const path3 = stripTsExtension(`${pathPrefix}/${meta.relativePath}`);
-      metaType = `typeof import('${path3}')`;
+      let metaType = `typeof import("${path3}")`;
       if (/\.(ts|js|mjs)$/.test(meta.relativePath)) {
-        metaType += `['default']`;
+        metaType += `["default"]`;
       }
+      routesWriter.writeBlockStart(`"${pathType}": {`).writeLines(`verb: ${verbType};`, `meta: ${metaType};`).writeBlockEnd("};");
+    } else {
+      routesWriter.writeLines(`"${pathType}": { verb: ${verbType} };`);
     }
     if (handler) {
       writeModuleDeclaration(
-        serverWriter,
+        moduleWriter,
         `${pathPrefix}/${handler.relativePath}`,
-        routeType,
-        platformType
+        `Run.Routes[${routeType}]`
       );
     }
     if (page) {
       writeModuleDeclaration(
         writer,
         `${pathPrefix}/${page.relativePath}`,
-        routeType,
-        platformType,
+        `Run.Routes[${routeType}]`,
         `
   export interface Input {
     renderBody: Marko.Body;
@@ -1097,45 +1078,20 @@ interface NoMeta {}
         }
       }
     }
-    routesWriter.writeLines(
-      `type ${routeType} = AnyRoute<${paramsType}, ${metaType}, ${pathType}>;`
-    );
-  }
-  pathsWriter.write(`type Get =`);
-  if (getPaths.size) {
-    for (const path3 of getPaths) {
-      pathsWriter.write(`
-  | '${path3}'`);
-    }
-  } else {
-    pathsWriter.write(" never");
-  }
-  pathsWriter.writeLines(";", "");
-  pathsWriter.write("type Post =");
-  if (postPaths.size) {
-    for (const path3 of postPaths) {
-      pathsWriter.write(`
-  | '${path3}'`);
-    }
-  } else {
-    pathsWriter.write(" never");
   }
-  pathsWriter.writeLines(";", "");
-  pathsWriter.join();
+  routesWriter.join();
   for (const [file, { routeTypes }] of middlewareRouteTypes) {
     writeModuleDeclaration(
-      serverWriter,
+      moduleWriter,
       `${pathPrefix}/${file.relativePath}`,
-      routeTypes.join(" | "),
-      platformType
+      `Run.Routes[${routeTypes.join(" | ")}]`
     );
   }
   for (const [file, { routeTypes }] of layoutRouteTypes) {
     writeModuleDeclaration(
       writer,
       `${pathPrefix}/${file.relativePath}`,
-      routeTypes.join(" | "),
-      platformType,
+      `Run.Routes[${routeTypes.join(" | ")}]`,
       `
   export interface Input {
     renderBody: Marko.Body;
@@ -1146,8 +1102,7 @@ interface NoMeta {}
     writeModuleDeclaration(
       writer,
       `${pathPrefix}/${routes.special["404"].page.relativePath}`,
-      void 0,
-      platformType,
+      "Run.Route",
       `
   export interface Input {}`
     );
@@ -1156,51 +1111,41 @@ interface NoMeta {}
     writeModuleDeclaration(
       writer,
       `${pathPrefix}/${routes.special["500"].page.relativePath}`,
-      void 0,
-      platformType,
+      "globalThis.MarkoRun.Route",
       `
   export interface Input {
     error: unknown;
   }`
     );
   }
-  serverWriter.join();
+  moduleWriter.join();
   return writer.end();
 }
-function writeModuleDeclaration(writer, path3 = "global", routeType = "AnyRoute", platformType = "unknown", moduleTypes) {
-  writer.writeLines("");
-  if (path3 === "global") {
-    writer.write("declare global {");
-  } else {
-    writer.write(`declare module '${stripTsExtension(path3)}' {`);
-  }
+function writeModuleDeclaration(writer, path3, routeType, moduleTypes) {
+  writer.writeLines("").write(`declare module "${stripTsExtension(path3)}" {`);
   if (moduleTypes) {
-    writer.writeLines(moduleTypes);
+    writer.write(moduleTypes);
   }
-  const isMarko = path3.endsWith(".marko");
-  writer.write(`
-  namespace MarkoRun {
-    type GetPaths = Get;
-    type PostPaths = Post;
-    type GetablePath<T extends string> = ValidatePath<Get, T>;
-    type GetableHref<T extends string> = ValidateHref<Get, T>; 
-    type PostablePath<T extends string> = ValidatePath<Post, T>;
-    type PostableHref<T extends string> = ValidateHref<Post, T>;
-    type Platform = ${platformType};`);
-  if (path3 !== "global") {
+  if (routeType) {
+    const isMarko = path3.endsWith(".marko");
     writer.write(`
-    type Route = ${routeType};
-    type Context = AnyContext<Platform, Route>${isMarko ? " & Marko.Global" : ""};
-    type Handler<_Params = Route['params'], _Meta = Route['meta']> = HandlerLike<Route>;
-    function route(handler: Handler): typeof handler;
-    function route<_Params = Route['params'], _Meta = Route['meta']>(handler: Handler): typeof handler;
-    const NotHandled: unique symbol;
-    const NotMatched: unique symbol;`);
+  namespace MarkoRun {
+    export * from "@marko/run/namespace";
+    export type Route = ${routeType};
+    export type Context = Run.MultiRouteContext<Route>${isMarko ? " & Marko.Global" : ""};
+    export type Handler = Run.HandlerLike<Route>;
+    export const route: Run.HandlerTypeFn<Handler>;
+  }`);
   }
   writer.writeLines(`
-  }
 }`);
 }
+function pathToURLPatternString(path3) {
+  return path3.replace(/\/\$(\$?)([^\/]*)/g, (_, catchAll, name) => {
+    name = decodeURIComponent(name);
+    return catchAll ? `/:${name || "rest"}*` : `/:${name}`;
+  });
+}
 
 // src/vite/utils/ast.ts
 var t = __toESM(require("@babel/types"), 1);

package/dist/vite/index.js

@@ -195,7 +195,7 @@ async function buildRoutes(walk, basePath) {
             });
           }
         }
-        pathStack.push(name.toLowerCase());
+        pathStack.push(name);
       }
       dirStack.push(name);
       isRoot = false;
@@ -643,9 +643,11 @@ function renderRouter(routes, options = {
       `import page${key} from '${virtualFilePrefix}/${markoRunFilePrefix}special__${key}.marko${serverEntryQuery}';`
     );
   }
-  writer.writeLines(`
+  writer.writeLines(
+    `
 globalThis.__marko_run__ = { match, fetch, invoke };
-    `).writeBlockStart(`export function match(method, pathname) {`).writeLines(
+    `
+  ).writeBlockStart(`export function match(method, pathname) {`).writeLines(
     `if (!pathname) {
     pathname = '/';
   } else if (pathname.charAt(0) !== '/') {
@@ -905,22 +907,13 @@ function renderParamsInfo(params, pathIndex) {
   }
   return result ? result + " }" : "{}";
 }
-function renderParamsInfoType(params) {
-  if (!params.length) {
-    return "{}";
-  }
-  let result = "{";
-  for (const { name } of params) {
-    result += ` ${wrapPropertyName(name)}: string;`;
-  }
-  return result + " }";
-}
 function renderMatch(verb, route, pathIndex) {
   var _a;
   const handler = `${verb}${route.index}`;
   const params = ((_a = route.params) == null ? void 0 : _a.length) ? renderParamsInfo(route.params, pathIndex) : "{}";
   const meta = route.meta ? `meta${route.index}` : "{}";
-  return `{ handler: ${handler}, params: ${params}, meta: ${meta} }`;
+  const path3 = pathToURLPatternString(route.path);
+  return `{ handler: ${handler}, params: ${params}, meta: ${meta}, path: '${path3}' }`;
 }
 function renderMiddleware(middleware) {
   const writer = createStringWriter();
@@ -957,76 +950,64 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
   Do NOT manually edit this file or your changes will be lost.
 */
 `,
-    `import type { HandlerLike, Route as AnyRoute, Context as AnyContext, ParamsObject, ValidatePath, ValidateHref } from "@marko/run";`
+    `import "@marko/run/namespace";`,
+    `import type Run from "@marko/run";`
   );
-  let platformType = "unknown";
+  const headWriter = writer.branch("head");
+  writer.writeLines("\n").writeBlockStart(`declare module "@marko/run" {`);
   if (adapter && adapter.typeInfo) {
-    platformType = await adapter.typeInfo((data) => writer.write(data));
-    writer.writeLines("");
-  }
-  writer.writeLines(`
-interface NoParams extends ParamsObject {}
-interface NoMeta {}
+    const platformType = await adapter.typeInfo(
+      (data) => headWriter.write(data)
+    );
+    if (platformType) {
+      writer.writeLines(`interface Platform extends ${platformType} {}
 `);
-  const pathsWriter = writer.branch("paths");
-  const routesWriter = writer.branch("types");
-  const serverWriter = writer.branch("server");
+    }
+  }
+  writer.writeBlockStart(`interface AppData extends Run.DefineApp<{`).writeBlockStart("routes: {");
+  const routesWriter = writer.branch("routes");
+  writer.writeBlockEnd("}").writeBlockEnd(`}> {}`).writeBlockEnd(`}`);
+  headWriter.join();
+  const moduleWriter = writer.branch("module");
   const middlewareRouteTypes = /* @__PURE__ */ new Map();
   const layoutRouteTypes = /* @__PURE__ */ new Map();
-  const getPaths = /* @__PURE__ */ new Set();
-  const postPaths = /* @__PURE__ */ new Set();
-  writeModuleDeclaration(serverWriter, void 0, void 0, platformType);
   for (const route of routes.list) {
-    const { meta, handler, params, middleware, page, layouts } = route;
-    const routeType = `Route${route.index}`;
-    const pathType = `\`${route.path.replace(
-      /\/\$(\$?)([^\/]*)/,
-      (_, catchAll, name) => {
-        name = decodeURIComponent(name);
-        return catchAll ? `/:${name || "rest"}*` : `/:${name}`;
-      }
-    )}\``;
-    const paramsType = (params == null ? void 0 : params.length) ? renderParamsInfoType(params) : "NoParams";
-    let metaType = "NoMeta";
+    const { meta, handler, middleware, page, layouts } = route;
+    const pathType = `${pathToURLPatternString(route.path)}`;
+    const routeType = `"${pathType}"`;
+    let verbType = "";
     if (page || handler) {
-      const isGet = page || ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.includes("get"));
-      const isPost = (_b = handler == null ? void 0 : handler.verbs) == null ? void 0 : _b.includes("post");
-      if (isGet || isPost) {
-        const path3 = route.path.replace(/\$(\$?)([^/]+)/g, (_, catchAll, name) => {
-          name = decodeURIComponent(name);
-          return catchAll ? `\${...${name}}` : `\${${name}}`;
-        });
-        const splatIndex = path3.indexOf("/${...");
-        if (splatIndex >= 0) {
-          const path22 = path3.slice(0, splatIndex) || "/";
-          isGet && getPaths.add(path22);
-          isPost && postPaths.add(path22);
-        }
-        isGet && getPaths.add(path3);
-        isPost && postPaths.add(path3);
+      const verbs = [];
+      if (page || ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.includes("get"))) {
+        verbs.push(`"get"`);
+      }
+      if ((_b = handler == null ? void 0 : handler.verbs) == null ? void 0 : _b.includes("post")) {
+        verbs.push(`"post"`);
       }
+      verbType = verbs.join(" | ");
     }
     if (meta) {
       const path3 = stripTsExtension(`${pathPrefix}/${meta.relativePath}`);
-      metaType = `typeof import('${path3}')`;
+      let metaType = `typeof import("${path3}")`;
       if (/\.(ts|js|mjs)$/.test(meta.relativePath)) {
-        metaType += `['default']`;
+        metaType += `["default"]`;
       }
+      routesWriter.writeBlockStart(`"${pathType}": {`).writeLines(`verb: ${verbType};`, `meta: ${metaType};`).writeBlockEnd("};");
+    } else {
+      routesWriter.writeLines(`"${pathType}": { verb: ${verbType} };`);
     }
     if (handler) {
       writeModuleDeclaration(
-        serverWriter,
+        moduleWriter,
         `${pathPrefix}/${handler.relativePath}`,
-        routeType,
-        platformType
+        `Run.Routes[${routeType}]`
       );
     }
     if (page) {
       writeModuleDeclaration(
         writer,
         `${pathPrefix}/${page.relativePath}`,
-        routeType,
-        platformType,
+        `Run.Routes[${routeType}]`,
         `
   export interface Input {
     renderBody: Marko.Body;
@@ -1060,45 +1041,20 @@ interface NoMeta {}
         }
       }
     }
-    routesWriter.writeLines(
-      `type ${routeType} = AnyRoute<${paramsType}, ${metaType}, ${pathType}>;`
-    );
-  }
-  pathsWriter.write(`type Get =`);
-  if (getPaths.size) {
-    for (const path3 of getPaths) {
-      pathsWriter.write(`
-  | '${path3}'`);
-    }
-  } else {
-    pathsWriter.write(" never");
-  }
-  pathsWriter.writeLines(";", "");
-  pathsWriter.write("type Post =");
-  if (postPaths.size) {
-    for (const path3 of postPaths) {
-      pathsWriter.write(`
-  | '${path3}'`);
-    }
-  } else {
-    pathsWriter.write(" never");
   }
-  pathsWriter.writeLines(";", "");
-  pathsWriter.join();
+  routesWriter.join();
   for (const [file, { routeTypes }] of middlewareRouteTypes) {
     writeModuleDeclaration(
-      serverWriter,
+      moduleWriter,
       `${pathPrefix}/${file.relativePath}`,
-      routeTypes.join(" | "),
-      platformType
+      `Run.Routes[${routeTypes.join(" | ")}]`
     );
   }
   for (const [file, { routeTypes }] of layoutRouteTypes) {
     writeModuleDeclaration(
       writer,
       `${pathPrefix}/${file.relativePath}`,
-      routeTypes.join(" | "),
-      platformType,
+      `Run.Routes[${routeTypes.join(" | ")}]`,
       `
   export interface Input {
     renderBody: Marko.Body;
@@ -1109,8 +1065,7 @@ interface NoMeta {}
     writeModuleDeclaration(
       writer,
       `${pathPrefix}/${routes.special["404"].page.relativePath}`,
-      void 0,
-      platformType,
+      "Run.Route",
       `
   export interface Input {}`
     );
@@ -1119,51 +1074,41 @@ interface NoMeta {}
     writeModuleDeclaration(
       writer,
       `${pathPrefix}/${routes.special["500"].page.relativePath}`,
-      void 0,
-      platformType,
+      "globalThis.MarkoRun.Route",
       `
   export interface Input {
     error: unknown;
   }`
     );
   }
-  serverWriter.join();
+  moduleWriter.join();
   return writer.end();
 }
-function writeModuleDeclaration(writer, path3 = "global", routeType = "AnyRoute", platformType = "unknown", moduleTypes) {
-  writer.writeLines("");
-  if (path3 === "global") {
-    writer.write("declare global {");
-  } else {
-    writer.write(`declare module '${stripTsExtension(path3)}' {`);
-  }
+function writeModuleDeclaration(writer, path3, routeType, moduleTypes) {
+  writer.writeLines("").write(`declare module "${stripTsExtension(path3)}" {`);
   if (moduleTypes) {
-    writer.writeLines(moduleTypes);
+    writer.write(moduleTypes);
   }
-  const isMarko = path3.endsWith(".marko");
-  writer.write(`
-  namespace MarkoRun {
-    type GetPaths = Get;
-    type PostPaths = Post;
-    type GetablePath<T extends string> = ValidatePath<Get, T>;
-    type GetableHref<T extends string> = ValidateHref<Get, T>; 
-    type PostablePath<T extends string> = ValidatePath<Post, T>;
-    type PostableHref<T extends string> = ValidateHref<Post, T>;
-    type Platform = ${platformType};`);
-  if (path3 !== "global") {
+  if (routeType) {
+    const isMarko = path3.endsWith(".marko");
     writer.write(`
-    type Route = ${routeType};
-    type Context = AnyContext<Platform, Route>${isMarko ? " & Marko.Global" : ""};
-    type Handler<_Params = Route['params'], _Meta = Route['meta']> = HandlerLike<Route>;
-    function route(handler: Handler): typeof handler;
-    function route<_Params = Route['params'], _Meta = Route['meta']>(handler: Handler): typeof handler;
-    const NotHandled: unique symbol;
-    const NotMatched: unique symbol;`);
+  namespace MarkoRun {
+    export * from "@marko/run/namespace";
+    export type Route = ${routeType};
+    export type Context = Run.MultiRouteContext<Route>${isMarko ? " & Marko.Global" : ""};
+    export type Handler = Run.HandlerLike<Route>;
+    export const route: Run.HandlerTypeFn<Handler>;
+  }`);
   }
   writer.writeLines(`
-  }
 }`);
 }
+function pathToURLPatternString(path3) {
+  return path3.replace(/\/\$(\$?)([^\/]*)/g, (_, catchAll, name) => {
+    name = decodeURIComponent(name);
+    return catchAll ? `/:${name || "rest"}*` : `/:${name}`;
+  });
+}
 
 // src/vite/utils/ast.ts
 import * as t from "@babel/types";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marko/run",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "The Marko application framework.",
   "license": "MIT",
   "homepage": "https://github.com/marko-js/run/tree/main/packages/run",
@@ -32,6 +32,9 @@
       "import": "./dist/runtime/index.js",
       "require": "./dist/runtime/index.cjs"
     },
+    "./namespace": {
+      "types": "./dist/runtime/namespace.d.ts"
+    },
     "./router": {
       "types": "./dist/runtime/router.d.ts",
       "import": "./dist/runtime/router.js",
@@ -58,6 +61,9 @@
       "*": [
         "./dist/runtime/index.d.ts"
       ],
+      "namespace": [
+        "./dist/runtime/namespace.d.ts"
+      ],
       "router": [
         "./dist/runtime/router.d.ts"
       ],

package/dist/adapter/dev-entry.mjs

@@ -1,36 +0,0 @@
-import { createServer } from "vite";
-
-let activeDevServers;
-
-process
-  .on("message", (message) => {
-    switch (message.type) {
-      case "start":
-        return start(message.entry, message.config);
-      case "shutdown":
-        return shutdown();
-    }
-  })
-  .send("ready");
-
-async function start(entry, config) {
-  let changed = false;
-  const loader = await createServer(config);
-  ({ activeDevServers } = await loader.ssrLoadModule("@marko/run/adapter"));
-  await loader.ssrLoadModule(entry);
-
-  loader.watcher.on("change", (path) => {
-    if (!changed && loader.moduleGraph.getModulesByFile(path)) {
-      changed = true;
-      process.send("restart");
-    }
-  });
-}
-
-function shutdown() {
-  if (activeDevServers) {
-    for (const devServer of activeDevServers) {
-      devServer.ws.send({ type: "full-reload" });
-    }
-  }
-}

package/dist/index.html

@@ -1 +0,0 @@
-<!doctype html><html lang=en><head><meta charset=UTF-8><title>@marko/run Test Fixture</title><script async type="module" crossorigin src="/assets/__marko-run__route__index.marko-3cfb730f.js"></script></head><body><div id=app>Page rendered</div></body></html>