@marko/run 0.6.6 → 0.7.1

package/dist/runtime/internal.cjs

@@ -29,7 +29,6 @@ __export(internal_exports, {
   normalize: () => normalize,
   notHandled: () => notHandled,
   notMatched: () => notMatched,
-  pageResponse: () => pageResponse,
   passthrough: () => passthrough,
   stripResponseBody: () => stripResponseBody,
   stripResponseBodySync: () => stripResponseBodySync
@@ -47,6 +46,7 @@ var NotHandled = Symbol(
 var NotMatched = Symbol(
   "marko-run not matched"
 );
+var parentContextLookup = /* @__PURE__ */ new WeakMap();
 var serializedGlobals = { params: true, url: true };
 var pageResponseInit = {
   status: 200,
@@ -86,37 +86,65 @@ var toReadable = (rendered) => {
   };
   return toReadable(rendered);
 };
-function pageResponse(template, input, init = pageResponseInit) {
-  return new Response(toReadable(template.render(input)), init);
-}
 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
-  } : {
+  let meta;
+  let params;
+  let path;
+  if (route) {
+    meta = route.meta;
+    params = route.params;
+    path = route.path;
+  } else {
+    meta = {};
+    params = {};
+    path = "";
+  }
+  return {
     request,
     url,
     platform,
-    meta: {},
-    params: {},
-    route: "",
-    serializedGlobals
-  };
-  let input;
-  return [
-    context,
-    (data) => {
-      input ?? (input = {
-        $global: context
-      });
-      return data ? Object.assign(input, data) : input;
+    meta,
+    params,
+    route: path,
+    serializedGlobals,
+    parent: parentContextLookup.get(request),
+    async fetch(resource, init) {
+      let request2;
+      let url2;
+      if (resource instanceof Request) {
+        request2 = new Request(resource, init);
+        url2 = new URL(request2.url);
+      } else {
+        url2 = typeof resource === "string" ? new URL(resource, this.url) : resource;
+        request2 = new Request(url2, init);
+      }
+      parentContextLookup.set(request2, this);
+      return await globalThis.__marko_run__.fetch(request2, this.platform) || new Response(null, { status: 404 });
+    },
+    render(template, input, init = pageResponseInit) {
+      return new Response(
+        toReadable(
+          template.render({
+            ...input,
+            $global: this
+          })
+        ),
+        init
+      );
+    },
+    redirect(to, status) {
+      return Response.redirect(
+        typeof to === "string" ? new URL(to, this.url) : to,
+        status
+      );
+    },
+    back(fallback = "/", status) {
+      return this.redirect(
+        this.request.headers.get("referer") || fallback,
+        status
+      );
     }
-  ];
+  };
 }
 async function call(handler, next, context) {
   let response;
@@ -223,7 +251,6 @@ function notMatched() {
   normalize,
   notHandled,
   notMatched,
-  pageResponse,
   passthrough,
   stripResponseBody,
   stripResponseBodySync

package/dist/runtime/internal.d.ts

@@ -1,8 +1,7 @@
-import type { AnyRoute, Awaitable, Context, InputObject, MultiRouteContext, NextFunction, Platform, RouteHandler } from "./types";
+import type { AnyRoute, Awaitable, Context, MultiRouteContext, NextFunction, Platform, RouteHandler } from "./types";
 export declare const NotHandled: typeof MarkoRun.NotHandled;
 export declare const NotMatched: typeof MarkoRun.NotMatched;
-export declare function pageResponse(template: Marko.Template, input: Record<PropertyKey, unknown>, init?: ResponseInit): 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 createContext<TRoute extends AnyRoute>(route: TRoute | null, request: Request, platform: Platform, url?: URL): Context<TRoute>;
 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;

package/dist/runtime/internal.js

@@ -5,6 +5,7 @@ var NotHandled = Symbol(
 var NotMatched = Symbol(
   "marko-run not matched"
 );
+var parentContextLookup = /* @__PURE__ */ new WeakMap();
 var serializedGlobals = { params: true, url: true };
 var pageResponseInit = {
   status: 200,
@@ -44,37 +45,65 @@ var toReadable = (rendered) => {
   };
   return toReadable(rendered);
 };
-function pageResponse(template, input, init = pageResponseInit) {
-  return new Response(toReadable(template.render(input)), init);
-}
 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
-  } : {
+  let meta;
+  let params;
+  let path;
+  if (route) {
+    meta = route.meta;
+    params = route.params;
+    path = route.path;
+  } else {
+    meta = {};
+    params = {};
+    path = "";
+  }
+  return {
     request,
     url,
     platform,
-    meta: {},
-    params: {},
-    route: "",
-    serializedGlobals
-  };
-  let input;
-  return [
-    context,
-    (data) => {
-      input ?? (input = {
-        $global: context
-      });
-      return data ? Object.assign(input, data) : input;
+    meta,
+    params,
+    route: path,
+    serializedGlobals,
+    parent: parentContextLookup.get(request),
+    async fetch(resource, init) {
+      let request2;
+      let url2;
+      if (resource instanceof Request) {
+        request2 = new Request(resource, init);
+        url2 = new URL(request2.url);
+      } else {
+        url2 = typeof resource === "string" ? new URL(resource, this.url) : resource;
+        request2 = new Request(url2, init);
+      }
+      parentContextLookup.set(request2, this);
+      return await globalThis.__marko_run__.fetch(request2, this.platform) || new Response(null, { status: 404 });
+    },
+    render(template, input, init = pageResponseInit) {
+      return new Response(
+        toReadable(
+          template.render({
+            ...input,
+            $global: this
+          })
+        ),
+        init
+      );
+    },
+    redirect(to, status) {
+      return Response.redirect(
+        typeof to === "string" ? new URL(to, this.url) : to,
+        status
+      );
+    },
+    back(fallback = "/", status) {
+      return this.redirect(
+        this.request.headers.get("referer") || fallback,
+        status
+      );
     }
-  ];
+  };
 }
 async function call(handler, next, context) {
   let response;
@@ -180,7 +209,6 @@ export {
   normalize,
   notHandled,
   notMatched,
-  pageResponse,
   passthrough,
   stripResponseBody,
   stripResponseBodySync

package/dist/runtime/types.d.ts

@@ -21,6 +21,11 @@ export interface Context<TRoute extends Route = AnyRoute> {
     readonly meta: TRoute["meta"];
     readonly platform: Platform;
     readonly serializedGlobals: Record<string, boolean>;
+    readonly parent: Context | undefined;
+    render<T>(template: Marko.Template<T>, input: T, init?: ResponseInit): Response;
+    fetch(resource: string | URL | Request, init?: RequestInit): Promise<Response>;
+    redirect(to: string | URL, status?: number): Response;
+    back(fallback?: string | URL, status?: number): Response;
 }
 export type MultiRouteContext<TRoute extends Route, _Preserved extends TRoute = TRoute> = TRoute extends any ? Context<Simplify<SuperSets<TRoute, _Preserved, "params">>> : never;
 export type ParamsObject = Record<string, string>;
@@ -46,7 +51,7 @@ type DefinePaths<T extends Record<string, {
 }>, 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;
+    } ? V extends Verb ? K : never : never : never;
 }[keyof T];
 export type DefineApp<T extends {
     routes: Record<string, {
@@ -70,7 +75,8 @@ export interface RuntimeModule {
     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 PathParamKeys<Path extends string> = Path extends `${infer _}$${infer Param}/${infer Rest}` ? [Unescape<Param>, ...PathParamKeys<Rest>] : Path extends `${infer _}$$${infer Param}` ? [Unescape<Param>] : Path extends `${infer _}$${infer Param}` ? [Unescape<Param>] : [];
+type Unescape<Escaped extends string> = Escaped extends `\`${infer Value}\`` ? Value : Escaped;
 type PathParams<Path extends string, Keys extends string[] = PathParamKeys<Path>> = 0 extends Keys["length"] ? NoParams : {
     [K in Keys[number]]: string;
 };
@@ -78,7 +84,6 @@ type Segments<T extends string, Acc extends string[] = []> = T extends "" ? Acc
 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 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 {

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

@@ -1,7 +1,6 @@
 import type { Adapter, BuiltRoutes, RoutableFile, Route, RouterOptions } from "../types";
-export declare function renderRouteTemplate(route: Route, getRelativePath: (path: string) => string): string;
-export declare function renderEntryTemplate(name: string, files: string[], pageInputs?: string[]): string;
-export declare function renderRouteEntry(route: Route, entriesDir: string): string;
-export declare function renderRouter(routes: BuiltRoutes, entriesDir: string, options?: RouterOptions): string;
-export declare function renderMiddleware(middleware: RoutableFile[]): string;
-export declare function renderRouteTypeInfo(routes: BuiltRoutes, pathPrefix?: string, adapter?: Adapter | null): Promise<string>;
+export declare function renderRouteTemplate(route: Route, rootDir: string): string;
+export declare function renderRouteEntry(route: Route, rootDir: string): string;
+export declare function renderRouter(routes: BuiltRoutes, rootDir: string, options?: RouterOptions): string;
+export declare function renderMiddleware(middleware: RoutableFile[], rootDir: string): string;
+export declare function renderRouteTypeInfo(routes: BuiltRoutes, outDir: string, adapter?: Adapter | null): Promise<string>;