@marko/run 0.10.0 → 0.11.0-rc.2

package/dist/runtime/internal.js

@@ -1,3 +1,7 @@
+// src/runtime/internal.ts
+import { URLSearchParams as URLSearchParams2 } from "node:url";
+import { parseFormData } from "@remix-run/form-data-parser";
+
 // src/vite/constants.ts
 var httpVerbs = [
   "get",
@@ -9,6 +13,83 @@ var httpVerbs = [
   "options"
 ];
 
+// src/runtime/thenable.ts
+var kPromise = /* @__PURE__ */ Symbol("promise");
+var kReadFn = /* @__PURE__ */ Symbol("read fn");
+function thenFn(resolve, reject) {
+  return (this[kPromise] || (this[kPromise] = this[kReadFn]())).then(resolve, reject);
+}
+function catchFn(reject) {
+  return (this[kPromise] || (this[kPromise] = this[kReadFn]())).catch(reject);
+}
+function finallyFn(resolve) {
+  return (this[kPromise] || (this[kPromise] = this[kReadFn]())).finally(resolve);
+}
+function thenable(fn) {
+  return {
+    [kPromise]: null,
+    [kReadFn]: fn,
+    then: thenFn,
+    catch: catchFn,
+    finally: finallyFn
+  };
+}
+
+// src/runtime/url-builder.ts
+var encode = encodeURIComponent;
+var pathParts = /* @__PURE__ */ new Map();
+function parsePathParts(path) {
+  let parts = pathParts.get(path);
+  if (!parts) {
+    let lastEnd = 0;
+    let paramStart;
+    pathParts.set(path, parts = [[]]);
+    while (lastEnd >= 0 && (paramStart = path.indexOf("/$", lastEnd) + 1)) {
+      parts.push(path.slice(lastEnd, paramStart++));
+      if (path.charAt(paramStart) === "$") {
+        paramStart++;
+        lastEnd = -1;
+      } else {
+        lastEnd = path.indexOf("/", paramStart);
+      }
+      parts[0].push(path.slice(paramStart, lastEnd < 0 ? void 0 : lastEnd));
+    }
+    parts.push(lastEnd >= 0 ? path.slice(lastEnd) : "");
+  }
+  return parts;
+}
+function joinHref(path, options) {
+  let result = path;
+  if (options.search) {
+    const query = "" + new URLSearchParams(options.search);
+    if (query) result += "?" + query;
+  }
+  if (options.hash) result += "#" + encode(options.hash);
+  return result;
+}
+function href(path, ...[options]) {
+  return options ? "params" in options ? ((parts) => href_keys(parts, options, ...parts[0]))(
+    parsePathParts(path)
+  ) : joinHref(path, options) : path;
+}
+function href_path(strings, ...params) {
+  let i = 0;
+  let j = 0;
+  let result = strings[i++];
+  if (!result || Array.isArray(result)) result = strings[i++];
+  while (i < strings.length) {
+    const param = params[j++];
+    result += (Array.isArray(param) ? param.map(encode).join("/") : encode(param)) + strings[i++];
+  }
+  return result;
+}
+function href_values(strings, options, ...params) {
+  return joinHref(href_path(strings, ...params), options);
+}
+function href_keys(strings, options, ...keys) {
+  return href_values(strings, options, ...keys.map((k) => options.params[k]));
+}
+
 // src/vite/utils/meta-data.ts
 var verbKeys = new Set(httpVerbs.map((v) => v.toUpperCase()));
 function isObject(obj) {
@@ -56,10 +137,17 @@ var pageResponseInit = {
 };
 globalThis.MarkoRun ?? (globalThis.MarkoRun = {
   NotHandled,
-  NotMatched,
-  route(handler) {
-    return handler;
-  }
+  NotMatched
+});
+globalThis.Run ?? (globalThis.Run = {
+  href,
+  ALL: createDefineHandler("ALL"),
+  ...Object.fromEntries(
+    httpVerbs.map((v) => {
+      const verb = v.toUpperCase();
+      return [v.toUpperCase(), createDefineHandler(verb)];
+    })
+  )
 });
 var toReadable = (rendered) => {
   toReadable = rendered.toReadable ? (rendered2) => rendered2.toReadable() : (rendered2) => {
@@ -88,27 +176,98 @@ var toReadable = (rendered) => {
   };
   return toReadable(rendered);
 };
-function createContext(route, request, platform, url = new URL(request.url)) {
-  let meta;
-  let params;
-  let path;
-  if (route) {
-    meta = route.meta;
-    params = route.params;
-    path = route.path;
-  } else {
-    meta = {};
-    params = {};
-    path = "";
+function searchParamsToObject(params) {
+  const obj = {};
+  for (const [key, value] of params) {
+    const prev = obj[key];
+    obj[key] = prev ? Array.isArray(prev) ? [...prev, value] : [prev, value] : value;
   }
-  return {
-    request,
+  return obj;
+}
+async function readBodyWithLimit(request, maxBytes) {
+  if (maxBytes < 0) {
+    return await request.text();
+  }
+  const contentLength = request.headers.get("content-length");
+  if (contentLength !== null && Number(contentLength) > maxBytes) {
+    throw new Error("Request body too large");
+  }
+  if (!request.body) {
+    throw new Error("Missing request body");
+  }
+  const reader = request.body.getReader();
+  const bytes = new Uint8Array(maxBytes);
+  let receivedBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (receivedBytes + value.byteLength > maxBytes) {
+        await reader.cancel();
+        throw new Error("Request body too large");
+      }
+      bytes.set(value, receivedBytes);
+      receivedBytes += value.byteLength;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return new TextDecoder("utf-8", { fatal: true }).decode(
+    bytes.subarray(0, receivedBytes)
+  );
+}
+async function readBody(route, context) {
+  const { request } = context;
+  const contentType = request.headers.get("Content-Type");
+  if (contentType == null ? void 0 : contentType.includes("application/json")) {
+    const { maxBytes: maxBytes2, validator: validator2 } = route.options.json;
+    const json = maxBytes2 < 0 ? await request.json() : JSON.parse(await readBodyWithLimit(request, maxBytes2));
+    return validator2 ? validator2(json) : json;
+  }
+  const { maxBytes, maxParts, maxFiles, maxFileBytes, onFile, validator } = route.options.form;
+  const data = searchParamsToObject(
+    (contentType == null ? void 0 : contentType.includes("multipart/form-data")) ? await parseFormData(
+      request,
+      {
+        maxParts,
+        maxFiles,
+        maxFileSize: maxFileBytes,
+        maxTotalSize: maxBytes
+      },
+      onFile ? (file) => onFile(context, file) : void 0
+    ) : new URLSearchParams2(await readBodyWithLimit(request, maxBytes))
+  );
+  return validator && validator(data);
+}
+function createContext(route, request, platform, url = new URL(request.url)) {
+  const context = {
+    route: (route == null ? void 0 : route.path) || "",
     method: request.method,
+    meta: (route == null ? void 0 : route.meta) || {},
+    get params() {
+      const value = route ? route.options.params ? route.options.params(route.params) : route.params : {};
+      Object.defineProperty(context, "params", {
+        configurable: true,
+        enumerable: true,
+        value
+      });
+      return value;
+    },
+    get search() {
+      const search = searchParamsToObject(url.searchParams);
+      const value = (route == null ? void 0 : route.options.search) ? route.options.search(search) : search;
+      Object.defineProperty(context, "search", {
+        configurable: true,
+        enumerable: true,
+        value
+      });
+      return value;
+    },
+    body: route && request.body ? thenable(() => readBody(route, context)) : void 0,
+    data: {},
     url,
+    request,
     platform,
-    meta,
-    params,
-    route: path,
     serializedGlobals,
     parent: parentContextLookup.get(request),
     async fetch(resource, init) {
@@ -150,16 +309,37 @@ function createContext(route, request, platform, url = new URL(request.url)) {
       );
     }
   };
+  return context;
+}
+function render(context, template, input, data) {
+  if (data) {
+    Object.assign(context.data, data);
+  }
+  return context.render(template, input);
 }
-async function call(handler, next, context) {
+var handlerMethod = /* @__PURE__ */ new WeakMap();
+async function call(handler, next, context, data) {
   let response;
+  if (data) {
+    Object.assign(context.data, data);
+  }
+  let method = handlerMethod.get(handler);
+  if (method === void 0) {
+    handlerMethod.set(
+      handler,
+      method = "verb" in handler && handler.verb !== "ALL" ? handler.verb : false
+    );
+  }
+  if (method && method !== context.method) {
+    return next(data);
+  }
   if (!process.env.NODE_ENV || process.env.NODE_ENV === "development") {
     let nextCallCount = 0;
     let didThrow = false;
     try {
-      response = await handler(context, () => {
+      response = await handler(context, (d) => {
         nextCallCount++;
-        return next();
+        return next(d);
       });
     } catch (error) {
       didThrow = true;
@@ -193,19 +373,19 @@ async function call(handler, next, context) {
   if (response === null || response === NotMatched || response === NotHandled) {
     throw response || NotMatched;
   }
-  return response || next();
+  return response || next(data);
 }
 function compose(handlers) {
   const len = handlers.length;
   if (!len) {
-    return (_context, next) => next();
+    return passthroughHandler;
   } 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();
+    return (function nextHandler(data) {
+      return i < len ? call(handlers[i++], nextHandler, context, data) : next(data);
     })();
   };
 }
@@ -226,6 +406,104 @@ function normalizeHandler(obj) {
   }
   return passthrough;
 }
+function assertHandlerVerb(verb, handler) {
+  if ("verb" in handler && handler.verb !== verb) {
+    throw new Error(
+      `Expected verb ${verb} but handler was defined with Run.${handler.verb}`
+    );
+  }
+}
+function createDefineHandler(verb) {
+  return (optionsOrHandlers, handlers) => {
+    let handler;
+    if (typeof optionsOrHandlers === "function") {
+      assertHandlerVerb(verb, optionsOrHandlers);
+      handler = optionsOrHandlers;
+      handler.options ?? (handler.options = {});
+    } else if (Array.isArray(optionsOrHandlers)) {
+      for (const h of optionsOrHandlers) assertHandlerVerb(verb, h);
+      handler = compose(optionsOrHandlers);
+      handler.options = mergeOptions(...optionsOrHandlers);
+    } else if (typeof handlers === "function") {
+      assertHandlerVerb(verb, handlers);
+      handler = handlers;
+      handler.options = mergeOptions(handlers, optionsOrHandlers);
+    } else if (Array.isArray(handlers)) {
+      for (const h of handlers) assertHandlerVerb(verb, h);
+      handler = compose(handlers);
+      handler.options = mergeOptions(...handlers, optionsOrHandlers);
+    } else {
+      handler = passthroughHandler;
+      handler.options = optionsOrHandlers;
+    }
+    handler.verb = verb;
+    return handler;
+  };
+}
+function normalizeValidator(validator) {
+  return validator && typeof validator !== "function" ? (input) => {
+    const result = validator["~standard"].validate(input);
+    if (result instanceof Promise) {
+      throw new TypeError("Schema validation must be synchronous");
+    }
+    return result.issues ? [input, result.issues] : [result.value, void 0];
+  } : validator;
+}
+var defaultMaxBytes = 1024 * 1024;
+var defaultMaxParts = 1e3;
+var defaultMaxFiles = 20;
+function mergeOptions(...arr) {
+  const merged = {};
+  for (const item of arr) {
+    let options;
+    if (typeof item === "object") {
+      options = item;
+    } else if ("options" in item) {
+      options = item.options;
+    } else {
+      continue;
+    }
+    for (const k in options) {
+      const key = k;
+      const option = options[key];
+      if (typeof option === "object" && typeof merged[key] === "object") {
+        Object.assign(merged[key], option);
+      } else if (option) {
+        merged[key] = option;
+      }
+    }
+  }
+  const result = {
+    params: normalizeValidator(merged.params),
+    search: normalizeValidator(merged.search)
+  };
+  if (merged.json) {
+    const { maxBytes = defaultMaxBytes, validator } = typeof merged.json === "function" || "~standard" in merged.json ? { validator: merged.json } : merged.json;
+    result.json = {
+      maxBytes,
+      validator: normalizeValidator(validator)
+    };
+  }
+  if (merged.form) {
+    const {
+      maxBytes,
+      maxFiles = defaultMaxFiles,
+      maxFileBytes = defaultMaxBytes,
+      maxParts = defaultMaxParts,
+      onFile,
+      validator
+    } = typeof merged.form === "function" || "~standard" in merged.form ? { validator: merged.form } : merged.form;
+    result.form = {
+      maxBytes: maxBytes ?? maxFiles * maxFileBytes,
+      maxFileBytes,
+      maxFiles,
+      maxParts,
+      onFile,
+      validator: normalizeValidator(validator)
+    };
+  }
+  return result;
+}
 function stripResponseBodySync(response) {
   return response.body ? new Response(null, response) : response;
 }
@@ -234,6 +512,7 @@ function stripResponseBody(response) {
 }
 function passthrough() {
 }
+var passthroughHandler = (_ctx, next) => next();
 function noContent() {
   return new Response(null, {
     status: 204
@@ -248,15 +527,19 @@ function notMatched() {
 export {
   NotHandled,
   NotMatched,
+  assertHandlerVerb,
   call,
   compose,
   createContext,
+  mergeOptions,
   noContent,
   normalizeHandler,
   getMetaDataLookup as normalizeMeta,
+  normalizeValidator,
   notHandled,
   notMatched,
   passthrough,
+  render,
   stripResponseBody,
   stripResponseBodySync
 };

package/dist/runtime/legacy-types.d.ts

@@ -0,0 +1,60 @@
+import type { AppPaths, Context, HttpVerb, NextFunction, NormalizedMeta, PathsForVerb, Route as NewRoute, RouteDef } from "./types";
+type OneOrMany<T> = T | T[];
+type NoParams = {};
+type AllKeys<T> = T extends T ? keyof T : never;
+type Simplify<T> = T extends unknown ? {
+    [K in keyof T]: T[K];
+} : never;
+type SuperSet<T, U extends T> = T & {
+    [K in AllKeys<U> as K extends keyof T ? never : K]?: never;
+};
+type SuperSets<T, U extends T, K extends keyof T> = Omit<T, K> & {
+    [P in K]: Simplify<SuperSet<T[P], U[P]>>;
+};
+type Union<T> = T[keyof T];
+type MigrateContext<T extends Route> = Context<NewRoute<RouteDef<T["path"], T["method"], T["meta"]>>>;
+export type Awaitable<T> = Promise<T> | T;
+export type MultiRouteContext<TRoute extends Route, _Preserved extends TRoute = TRoute> = TRoute extends any ? MigrateContext<Simplify<SuperSets<TRoute, _Preserved, "params">>> : never;
+export type ParamsObject = Record<string, string>;
+export type InputObject = Record<PropertyKey, any>;
+export type HandlerLike<TRoute extends Route = AnyRoute, Verb extends HttpVerb = HttpVerb> = Awaitable<OneOrMany<RouteHandler<TRoute, Verb>>>;
+export type RouteHandlerResult = Response | typeof MarkoRun.NotHandled | typeof MarkoRun.NotMatched | null | void;
+export type RouteHandler<TRoute extends Route = AnyRoute, Verb extends HttpVerb = HttpVerb> = (context: MultiRouteContext<Extract<TRoute, {
+    method: Verb;
+}>>, next: NextFunction) => Awaitable<RouteHandlerResult>;
+export interface Route<Params extends ParamsObject = ParamsObject, Meta = any, Path extends string = string, Verb extends HttpVerb = HttpVerb> {
+    path: Path;
+    params: Params;
+    meta: NormalizedMeta<Meta, Verb>;
+    method: Verb;
+}
+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}` ? [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;
+};
+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;
+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 {
+}
+export type Routes = [AppPaths] extends [never] ? Record<string, Route> : {
+    [Path in keyof AppPaths]: Union<{
+        [V in HttpVerb]: Route<PathParams<Path>, V extends keyof AppPaths[Path]["verbs"] ? AppPaths[Path]["verbs"][V]["def"]["meta"] : {}, Path, V>;
+    }>;
+};
+export type AnyRoute = Routes[keyof Routes];
+export type HandlerTypeFn<TRoute extends Route = AnyRoute> = [
+    AppPaths
+] extends [never] ? <T extends HandlerLike<TRoute>>(handler: T) => T : <Params extends ParamsObject = ParamsObject, Meta = any, T extends HandlerLike<Route<Params, Meta>> = HandlerLike<Route<Params, Meta>>>(handler: T) => T;
+export type GetPaths = PathsForVerb<"GET">;
+export type PostPaths = PathsForVerb<"POST">;
+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/runtime/namespace.d.ts

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

package/dist/runtime/router.d.ts

@@ -1,3 +1,3 @@
 export declare const fetch: <TPlatform extends import("./types").Platform = import("./types").Platform>(request: Request, platform: TPlatform) => ReturnType<import("./types").Fetch<TPlatform>>;
 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) => ReturnType<import("./types").Invoke<TPlatform>>;
+export declare const invoke: <TPlatform extends import("./types").Platform = import("./types").Platform>(route: import("./types").RouteMatch<import("./types").Context<import("./types").Route<import("./types").RouteDef<string, import("./types").HttpVerb, any, Record<string, any>, [any]>, any>>> | null, request: Request, platform: TPlatform) => ReturnType<import("./types").Invoke<TPlatform>>;

package/dist/runtime/thenable.d.ts

@@ -0,0 +1,11 @@
+declare const kPromise: unique symbol;
+declare const kReadFn: unique symbol;
+export interface Thenable<T = any> extends Promise<T> {
+    [kPromise]: null | Promise<T>;
+    [kReadFn]: () => Promise<T>;
+    then: Promise<T>["then"];
+    catch: Promise<T>["catch"];
+    finally: Promise<T>["finally"];
+}
+export default function thenable<T>(fn: () => Promise<T>): Thenable<T>;
+export {};