@marko/run 0.9.7 → 0.11.0-rc.1

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

@@ -25,12 +25,15 @@ __export(internal_exports, {
   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 +43,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 +58,61 @@ var httpVerbs = [
   "options"
 ];
 
+// 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) {
@@ -84,10 +146,10 @@ function getMetaDataLookup(data) {
 }
 
 // src/runtime/internal.ts
-var NotHandled = Symbol(
+var NotHandled = /* @__PURE__ */ Symbol(
   "marko-run not handled"
 );
-var NotMatched = Symbol(
+var NotMatched = /* @__PURE__ */ Symbol(
   "marko-run not matched"
 );
 var parentContextLookup = /* @__PURE__ */ new WeakMap();
@@ -98,11 +160,20 @@ var pageResponseInit = {
 };
 globalThis.MarkoRun ?? (globalThis.MarkoRun = {
   NotHandled,
-  NotMatched,
-  route(handler) {
-    return handler;
-  }
+  NotMatched
 });
+if (!globalThis.Run) {
+  const namespace = {
+    href
+  };
+  for (const v of [...httpVerbs, "all"]) {
+    const verb = v.toUpperCase();
+    const def = createDefineHandler();
+    def.href = href;
+    namespace[verb] = def;
+  }
+  globalThis.Run = namespace;
+}
 var toReadable = (rendered) => {
   toReadable = rendered.toReadable ? (rendered2) => rendered2.toReadable() : (rendered2) => {
     let cancelled = false;
@@ -130,39 +201,120 @@ 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)
+  );
+}
+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 ? async () => {
+      const contentType = request.headers.get("Content-Type");
+      let value;
+      if (contentType == null ? void 0 : contentType.includes("application/json")) {
+        const { maxBytes, validator } = route.options.json;
+        const json = maxBytes < 0 ? await request.json() : JSON.parse(await readBodyWithLimit(request, maxBytes));
+        value = validator ? validator(json) : json;
+      } else {
+        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)
+          )
+        );
+        value = validator ? validator(data) : validator;
+      }
+      Object.defineProperty(context, "body", {
+        configurable: true,
+        enumerable: true,
+        value
+      });
+      return value;
+    } : void 0,
+    data: {},
     url,
+    request,
     platform,
-    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);
-      }
+      const request2 = new Request(
+        typeof resource === "string" ? new URL(resource, this.url) : resource,
+        init
+      );
       parentContextLookup.set(request2, this);
       return await globalThis.__marko_run__.fetch(request2, this.platform) || new Response(null, { status: 404 });
     },
@@ -197,16 +349,26 @@ 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) {
+async function call(handler, next, context, data) {
   let response;
+  if (data) {
+    Object.assign(context.data, 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;
@@ -245,14 +407,14 @@ async function call(handler, next, context) {
 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);
     })();
   };
 }
@@ -273,6 +435,87 @@ function normalizeHandler(obj) {
   }
   return passthrough;
 }
+function createDefineHandler() {
+  return (optionsOrHandlers, handlers) => {
+    let handler;
+    if (typeof optionsOrHandlers === "function") {
+      handler = optionsOrHandlers;
+      handler.options = {};
+    } else if (Array.isArray(optionsOrHandlers)) {
+      handler = compose(optionsOrHandlers);
+      handler.options = {};
+    } else if (typeof handlers === "function") {
+      handler = handlers;
+      handler.options = optionsOrHandlers;
+    } else if (Array.isArray(handlers)) {
+      handler = compose(handlers);
+      handler.options = optionsOrHandlers;
+    } else {
+      handler = passthroughHandler;
+      handler.options = optionsOrHandlers;
+    }
+    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(...fns) {
+  const merged = {};
+  for (const fn of fns) {
+    if (typeof fn === "function" && "options" in fn) {
+      const { options } = fn;
+      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;
 }
@@ -281,6 +524,7 @@ function stripResponseBody(response) {
 }
 function passthrough() {
 }
+var passthroughHandler = (_ctx, next) => next();
 function noContent() {
   return new Response(null, {
     status: 204
@@ -299,12 +543,15 @@ function notMatched() {
   call,
   compose,
   createContext,
+  mergeOptions,
   noContent,
   normalizeHandler,
   normalizeMeta,
+  normalizeValidator,
   notHandled,
   notMatched,
   passthrough,
+  render,
   stripResponseBody,
   stripResponseBodySync
 });

package/dist/runtime/internal.d.ts

@@ -1,11 +1,15 @@
-import type { AnyRoute, Awaitable, Context, MultiRouteContext, NextFunction, Platform, RouteHandler } from "./types";
+import type { Awaitable, RouteHandler } from "./legacy-types";
+import type { Context, HandlerFunction, HandlerOptions, 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 normalizeValidator<T>(validator: Validator<T> | undefined): import("./types").ValidatorFn<T> | undefined;
+export declare function mergeOptions(...fns: (NormalizedHandler<Context, "ALL", any, HandlerOptions> | HandlerFunction)[]): NormalizedHandlerOptions;
 export declare function stripResponseBodySync(response: Response): Response;
 export declare function stripResponseBody(response: Awaitable<Response>): Awaitable<Response>;
 export declare function passthrough(): void;