@marko/run 0.0.1-beta1 → 0.0.1-beta10

package/dist/runtime/internal.cjs

@@ -0,0 +1,160 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  NotHandled: () => NotHandled,
+  NotMatched: () => NotMatched,
+  call: () => call,
+  compose: () => compose,
+  createInput: () => createInput,
+  noContent: () => noContent,
+  normalize: () => normalize,
+  notHandled: () => notHandled,
+  notMatched: () => notMatched,
+  pageResponse: () => pageResponse
+});
+module.exports = __toCommonJS(internal_exports);
+var pageResponseInit = {
+  status: 200,
+  headers: { "content-type": "text/html;charset=UTF-8" }
+};
+function pageResponse(template, input) {
+  return new Response(template.stream(input), pageResponseInit);
+}
+var NotHandled = Symbol();
+var NotMatched = Symbol();
+globalThis.MarkoRun ?? (globalThis.MarkoRun = {
+  NotHandled,
+  NotMatched,
+  route(handler) {
+    return handler;
+  }
+});
+function createInput(context) {
+  let existing;
+  return (data) => {
+    existing ?? (existing = {
+      $global: context
+    });
+    return data ? Object.assign(existing, data) : existing;
+  };
+}
+async function call(handler, next, context) {
+  let response;
+  if (process.env.NODE_ENV !== "production") {
+    let nextCallCount = 0;
+    let didThrow = false;
+    try {
+      response = await handler(context, () => {
+        nextCallCount++;
+        return next();
+      });
+    } catch (error) {
+      didThrow = true;
+      if (error instanceof Response) {
+        return error;
+      }
+      throw error;
+    } finally {
+      if (!response && !didThrow && nextCallCount > 0) {
+        console.warn(
+          `Handler '${handler.name}' called its next function but no response was returned. This will cause the next function to be called again which is wasteful. Either return or throw the result of calling \`next\`, return or throw a new Response object or finally \`throw null\` to skip handling the request`
+        );
+      } else if (nextCallCount > 1) {
+        console.warn(
+          `Handler '${handler.name}' called its next function more than once. Make sure this is intentional because it is inefficient.`
+        );
+      }
+    }
+  } else {
+    try {
+      response = await handler(context, next);
+    } catch (error) {
+      if (error == null) {
+        throw NotHandled;
+      } else if (error instanceof Response) {
+        return error;
+      }
+      throw error;
+    }
+  }
+  if (response === null) {
+    throw NotMatched;
+  }
+  return response || next();
+}
+function compose(handlers) {
+  const len = handlers.length;
+  if (!len) {
+    return (_context, next) => next();
+  } else if (len === 1) {
+    return handlers[0];
+  }
+  return (context, next) => {
+    let i = 0;
+    return function nextHandler() {
+      return i < len ? call(handlers[i++], nextHandler, context) : next();
+    }();
+  };
+}
+function normalize(obj) {
+  if (typeof obj === "function") {
+    return obj;
+  } else if (Array.isArray(obj)) {
+    return compose(obj);
+  } else if (obj instanceof Promise) {
+    const promise = obj.then((value) => {
+      fn = Array.isArray(value) ? compose(value) : value;
+    });
+    let fn = async (context, next) => {
+      await promise;
+      return fn(context, next);
+    };
+    return (context, next) => fn(context, next);
+  }
+  throw new Error(
+    `Invalid handler - expected function, array or Promise but received ${obj}`
+  );
+}
+function noContent() {
+  return new Response(null, {
+    status: 204
+  });
+}
+function notHandled() {
+  throw null;
+}
+function notMatched() {
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NotHandled,
+  NotMatched,
+  call,
+  compose,
+  createInput,
+  noContent,
+  normalize,
+  notHandled,
+  notMatched,
+  pageResponse
+});

package/dist/runtime/internal.d.ts

@@ -0,0 +1,11 @@
+import type { InputObject, NextFunction, Route, Context, RouteHandler } 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 createInput(context: 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;
+export declare function noContent(): Response;
+export declare function notHandled(): void;
+export declare function notMatched(): null;

package/dist/runtime/internal.js

@@ -0,0 +1,126 @@
+// src/runtime/internal.ts
+var pageResponseInit = {
+  status: 200,
+  headers: { "content-type": "text/html;charset=UTF-8" }
+};
+function pageResponse(template, input) {
+  return new Response(template.stream(input), pageResponseInit);
+}
+var NotHandled = Symbol();
+var NotMatched = Symbol();
+globalThis.MarkoRun ?? (globalThis.MarkoRun = {
+  NotHandled,
+  NotMatched,
+  route(handler) {
+    return handler;
+  }
+});
+function createInput(context) {
+  let existing;
+  return (data) => {
+    existing ?? (existing = {
+      $global: context
+    });
+    return data ? Object.assign(existing, data) : existing;
+  };
+}
+async function call(handler, next, context) {
+  let response;
+  if (process.env.NODE_ENV !== "production") {
+    let nextCallCount = 0;
+    let didThrow = false;
+    try {
+      response = await handler(context, () => {
+        nextCallCount++;
+        return next();
+      });
+    } catch (error) {
+      didThrow = true;
+      if (error instanceof Response) {
+        return error;
+      }
+      throw error;
+    } finally {
+      if (!response && !didThrow && nextCallCount > 0) {
+        console.warn(
+          `Handler '${handler.name}' called its next function but no response was returned. This will cause the next function to be called again which is wasteful. Either return or throw the result of calling \`next\`, return or throw a new Response object or finally \`throw null\` to skip handling the request`
+        );
+      } else if (nextCallCount > 1) {
+        console.warn(
+          `Handler '${handler.name}' called its next function more than once. Make sure this is intentional because it is inefficient.`
+        );
+      }
+    }
+  } else {
+    try {
+      response = await handler(context, next);
+    } catch (error) {
+      if (error == null) {
+        throw NotHandled;
+      } else if (error instanceof Response) {
+        return error;
+      }
+      throw error;
+    }
+  }
+  if (response === null) {
+    throw NotMatched;
+  }
+  return response || next();
+}
+function compose(handlers) {
+  const len = handlers.length;
+  if (!len) {
+    return (_context, next) => next();
+  } else if (len === 1) {
+    return handlers[0];
+  }
+  return (context, next) => {
+    let i = 0;
+    return function nextHandler() {
+      return i < len ? call(handlers[i++], nextHandler, context) : next();
+    }();
+  };
+}
+function normalize(obj) {
+  if (typeof obj === "function") {
+    return obj;
+  } else if (Array.isArray(obj)) {
+    return compose(obj);
+  } else if (obj instanceof Promise) {
+    const promise = obj.then((value) => {
+      fn = Array.isArray(value) ? compose(value) : value;
+    });
+    let fn = async (context, next) => {
+      await promise;
+      return fn(context, next);
+    };
+    return (context, next) => fn(context, next);
+  }
+  throw new Error(
+    `Invalid handler - expected function, array or Promise but received ${obj}`
+  );
+}
+function noContent() {
+  return new Response(null, {
+    status: 204
+  });
+}
+function notHandled() {
+  throw null;
+}
+function notMatched() {
+  return null;
+}
+export {
+  NotHandled,
+  NotMatched,
+  call,
+  compose,
+  createInput,
+  noContent,
+  normalize,
+  notHandled,
+  notMatched,
+  pageResponse
+};

package/dist/runtime/router.cjs

@@ -20,20 +20,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/runtime/router.ts
 var router_exports = {};
 __export(router_exports, {
-  getMatchedRoute: () => getMatchedRoute,
-  handler: () => handler,
-  router: () => router
+  fetch: () => fetch,
+  invoke: () => invoke,
+  match: () => match
 });
 module.exports = __toCommonJS(router_exports);
 function notImplemented() {
-  throw new Error("This should have been replaced by the @marko/run plugin at build/dev time");
+  throw new Error(
+    "This should have been replaced by the @marko/run plugin at build/dev time"
+  );
 }
-var handler = notImplemented;
-var router = notImplemented;
-var getMatchedRoute = notImplemented;
+var fetch = notImplemented;
+var match = notImplemented;
+var invoke = notImplemented;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getMatchedRoute,
-  handler,
-  router
+  fetch,
+  invoke,
+  match
 });

package/dist/runtime/router.d.ts

@@ -1,4 +1,3 @@
-import type { Handler, RouteMatcher, Router } from './types';
-export declare const handler: Handler;
-export declare const router: Router;
-export declare const getMatchedRoute: RouteMatcher;
+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>;

package/dist/runtime/router.js

@@ -1,12 +1,14 @@
 // src/runtime/router.ts
 function notImplemented() {
-  throw new Error("This should have been replaced by the @marko/run plugin at build/dev time");
+  throw new Error(
+    "This should have been replaced by the @marko/run plugin at build/dev time"
+  );
 }
-var handler = notImplemented;
-var router = notImplemented;
-var getMatchedRoute = notImplemented;
+var fetch = notImplemented;
+var match = notImplemented;
+var invoke = notImplemented;
 export {
-  getMatchedRoute,
-  handler,
-  router
+  fetch,
+  invoke,
+  match
 };

package/dist/runtime/types.d.ts

@@ -1,22 +1,45 @@
-import type { AdapterRequestContext } from '@hattip/core';
-export interface RouteContext<Params extends Record<string, string> = {}, Meta = unknown> {
-    request: Request;
+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;
+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 interface Route<Params extends ParamsObject = {}, Meta = unknown, Path extends string = string> {
+    path: Path;
     params: Params;
     meta: Meta;
-    error?: unknown;
 }
-export declare type RouteHandler<Params extends Record<string, string> = {}, Meta = unknown> = (context: RouteContext<Params, Meta>) => Promise<Response>;
-export interface MatchedRoute<Params extends Record<string, string> = {}, Meta = unknown> {
-    handler: RouteHandler;
-    params: Params;
-    meta: Meta;
-    invoke: Router;
+export interface RouteWithHandler<Params extends ParamsObject = {}, Meta = unknown, Path extends string = string> extends Route<Params, Meta, Path> {
+    handler: RouteHandler<this>;
 }
-export declare type Router = (request: Request) => Promise<Response>;
-export declare type RouteMatcher = (method: string, url: URL) => MatchedRoute | null;
-export declare type Handler = (context: AdapterRequestContext) => Promise<Response>;
-export interface Runtime {
-    router: Router;
-    getMatchedRoute: RouteMatcher;
+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 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>;
+export {};

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

@@ -1,5 +1,6 @@
-import type { Route, BuiltRoutes, CodegenOptions } from "../types";
-export declare const DefaultCodegenOptions: CodegenOptions;
+import type { 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?: CodegenOptions): 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;

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

@@ -2,7 +2,7 @@ export interface Writer {
     indent: number;
     branch(name: string): Writer;
     join(closeBranches?: boolean): void;
-    write(data: string): Writer;
+    write(data: string, indent?: boolean): Writer;
     writeLines(...lines: string[]): Writer;
     writeBlockStart(data: string): Writer;
     writeBlockEnd(data: string): Writer;

package/dist/vite/constants.d.ts

@@ -1,7 +1,8 @@
 declare type ValuesOf<T> = T[keyof T];
-export declare const markoServeFilePrefix = "__marko-serve__";
-export declare const virtualFilePrefix = "virtual:marko-serve";
+export declare const markoRunFilePrefix = "__marko-run__";
+export declare const virtualFilePrefix = "virtual:marko-run";
 export declare const virtualRoutesPrefix: string;
+export declare const virtualRuntimePrefix: string;
 export declare const httpVerbs: readonly ["get", "post", "put", "delete"];
 export declare const serverEntryQuery = "?marko-server-entry";
 export declare const browserEntryQuery = "?marko-browser-entry";