@marko/run 0.10.0 → 0.11.0-rc.2

package/dist/runtime/client.cjs

@@ -0,0 +1,65 @@
+"use strict";
+
+// scripts/importMetaURL.js
+var import_url = require("url");
+var __importMetaURL = (0, import_url.pathToFileURL)(__filename);
+
+// 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/runtime/client.ts
+window.Run || (window.Run = {
+  href
+});

package/dist/runtime/client.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client.js

@@ -0,0 +1,59 @@
+// 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/runtime/client.ts
+window.Run || (window.Run = {
+  href
+});

package/dist/runtime/index.d.ts

@@ -1,9 +1,15 @@
 import { InlineConfig } from "vite";
+import type { AnyRoute, GetableHref, GetablePath, GetPaths, HandlerLike, MultiRouteContext, PostableHref, PostablePath, PostPaths } from "./legacy-types";
 import { NotHandled, NotMatched } from "./namespace";
-import type { AnyRoute, GetableHref, GetablePath, GetPaths, HandlerLike, HandlerTypeFn, MultiRouteContext, Platform, PostableHref, PostablePath, PostPaths, RuntimeModule } from "./types";
+import type { GetContext, GlobalNamespace, Platform, RuntimeModule } from "./types";
 declare global {
     var __marko_run__: RuntimeModule;
     var __marko_run_vite_config__: InlineConfig | undefined;
+    var Run: GlobalNamespace;
+    namespace Run {
+        type Context = GetContext;
+    }
+    /** @deprecated use \`Run\` namespace instead */
     namespace MarkoRun {
         export { GetableHref, GetablePath, GetPaths, NotHandled, NotMatched, Platform, PostableHref, PostablePath, PostPaths, };
         export type Route = AnyRoute;
@@ -16,8 +22,7 @@ declare global {
         export type DELETE = HandlerLike<AnyRoute, "DELETE">;
         export type PATCH = HandlerLike<AnyRoute, "PATCH">;
         export type OPTIONS = HandlerLike<AnyRoute, "OPTIONS">;
-        /** @deprecated use `((context, next) => { ... }) satisfies MarkoRun.Handler` instead */
-        export const route: HandlerTypeFn;
     }
 }
-export type { AppData, Context, DefineApp, Fetch, HandlerLike, HandlerTypeFn, InputObject, Invoke, LayoutInput, Match, MultiRouteContext, NextFunction, ParamsObject, Platform, Route, RouteHandler, Routes, RouteWithHandler, RuntimeModule, Verb, } from "./types";
+export type { HandlerLike, HandlerTypeFn, InputObject, MultiRouteContext, ParamsObject, Route, RouteHandler, Routes, } from "./legacy-types";
+export type { App, Context, ContextForFile, DefineRoutes, Fetch, GetContext, Handler, Invoke, LayoutInput, Match, Meta, Middleware, Namespace, NextFunction, NormalizedHandler, PartialTemplate, Platform, RouteForFileDef, RouteMatch, RuntimeModule, Template, HttpVerb as Verb, } from "./types";

package/dist/runtime/internal.cjs

@@ -22,15 +22,19 @@ var internal_exports = {};
 __export(internal_exports, {
   NotHandled: () => NotHandled,
   NotMatched: () => NotMatched,
+  assertHandlerVerb: () => assertHandlerVerb,
   call: () => call,
   compose: () => compose,
   createContext: () => createContext,
+  mergeOptions: () => mergeOptions,
   noContent: () => noContent,
   normalizeHandler: () => normalizeHandler,
   normalizeMeta: () => getMetaDataLookup,
+  normalizeValidator: () => normalizeValidator,
   notHandled: () => notHandled,
   notMatched: () => notMatched,
   passthrough: () => passthrough,
+  render: () => render,
   stripResponseBody: () => stripResponseBody,
   stripResponseBodySync: () => stripResponseBodySync
 });
@@ -40,6 +44,10 @@ module.exports = __toCommonJS(internal_exports);
 var import_url = require("url");
 var __importMetaURL = (0, import_url.pathToFileURL)(__filename);
 
+// src/runtime/internal.ts
+var import_node_url = require("node:url");
+var import_form_data_parser = require("@remix-run/form-data-parser");
+
 // src/vite/constants.ts
 var httpVerbs = [
   "get",
@@ -51,6 +59,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) {
@@ -98,10 +183,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) => {
@@ -130,27 +222,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 (0, import_form_data_parser.parseFormData)(
+      request,
+      {
+        maxParts,
+        maxFiles,
+        maxFileSize: maxFileBytes,
+        maxTotalSize: maxBytes
+      },
+      onFile ? (file) => onFile(context, file) : void 0
+    ) : new import_node_url.URLSearchParams(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) {
@@ -192,16 +355,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;
@@ -235,19 +419,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);
     })();
   };
 }
@@ -268,6 +452,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;
 }
@@ -276,6 +558,7 @@ function stripResponseBody(response) {
 }
 function passthrough() {
 }
+var passthroughHandler = (_ctx, next) => next();
 function noContent() {
   return new Response(null, {
     status: 204
@@ -291,15 +574,19 @@ function notMatched() {
 0 && (module.exports = {
   NotHandled,
   NotMatched,
+  assertHandlerVerb,
   call,
   compose,
   createContext,
+  mergeOptions,
   noContent,
   normalizeHandler,
   normalizeMeta,
+  normalizeValidator,
   notHandled,
   notMatched,
   passthrough,
+  render,
   stripResponseBody,
   stripResponseBodySync
 });

package/dist/runtime/internal.d.ts

@@ -1,11 +1,16 @@
-import type { AnyRoute, Awaitable, Context, MultiRouteContext, NextFunction, Platform, RouteHandler } from "./types";
+import type { Awaitable, RouteHandler } from "./legacy-types";
+import type { Context, HandlerFunction, HandlerOptions, HttpVerbOrAll, NextFunction, NormalizedHandler, NormalizedHandlerOptions, Platform, RouteData, RouteMatch, Validator } from "./types";
 export { getMetaDataLookup as normalizeMeta } from "../vite/utils/meta-data";
 export declare const NotHandled: typeof MarkoRun.NotHandled;
 export declare const NotMatched: typeof MarkoRun.NotMatched;
-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 createContext(route: RouteMatch | null, request: Request, platform: Platform, url?: URL): Context;
+export declare function render<T>(context: Context, template: Marko.Template<T>, input: T, data?: RouteData): Response;
+export declare function call(handler: HandlerFunction, next: NextFunction, context: Context, data?: RouteData): Promise<Response>;
+export declare function compose(handlers: HandlerFunction[]): HandlerFunction;
 export declare function normalizeHandler(obj: RouteHandler | RouteHandler[] | Promise<RouteHandler | RouteHandler[]>): RouteHandler;
+export declare function assertHandlerVerb(verb: HttpVerbOrAll, handler: HandlerFunction): void;
+export declare function normalizeValidator<T>(validator: Validator<T> | undefined): import("./types").ValidatorFn<T> | undefined;
+export declare function mergeOptions(...arr: (NormalizedHandler<Context, "ALL", any, HandlerOptions> | HandlerFunction | HandlerOptions)[]): NormalizedHandlerOptions;
 export declare function stripResponseBodySync(response: Response): Response;
 export declare function stripResponseBody(response: Awaitable<Response>): Awaitable<Response>;
 export declare function passthrough(): void;