@marko/run 0.1.1 → 0.1.3

package/dist/vite/constants.d.ts

@@ -1,4 +1,4 @@
-declare type ValuesOf<T> = T[keyof T];
+type ValuesOf<T> = T[keyof T];
 export declare const markoRunFilePrefix = "__marko-run__";
 export declare const virtualFilePrefix = "virtual:marko-run";
 export declare const virtualRoutesPrefix: string;
@@ -15,6 +15,6 @@ export declare const RoutableFileTypes: {
     readonly NotFound: "404";
     readonly Error: "500";
 };
-export declare type RoutableFileType = ValuesOf<typeof RoutableFileTypes>;
-export declare type HttpVerb = typeof httpVerbs[number];
+export type RoutableFileType = ValuesOf<typeof RoutableFileTypes>;
+export type HttpVerb = typeof httpVerbs[number];
 export {};

package/dist/vite/index.cjs

@@ -26,7 +26,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/vite/index.ts
 var vite_exports = {};
 __export(vite_exports, {
-  default: () => markoServe,
+  default: () => markoRun,
   getAvailablePort: () => getAvailablePort,
   isPortInUse: () => isPortInUse,
   loadEnv: () => loadEnv,
@@ -663,7 +663,7 @@ function renderRouter(routes, options = {
   writer.writeLines(`// @marko/run/router`);
   const imports = writer.branch("imports");
   imports.writeLines(
-    `import { NotHandled, NotMatched, createInput } from 'virtual:marko-run/internal';`
+    `import { NotHandled, NotMatched, createContext } from 'virtual:marko-run/internal';`
   );
   for (const route of routes.list) {
     const verbs = getVerbs(route);
@@ -680,7 +680,17 @@ function renderRouter(routes, options = {
       `import page${key} from '${virtualFilePrefix}/${markoRunFilePrefix}special__${key}.marko${serverEntryQuery}';`
     );
   }
-  writer.writeLines(``).writeBlockStart(`export function match(method, pathname) {`).writeLines(
+  writer.writeLines(
+    `
+const page404ResponseInit = {
+  status: 404,
+  headers: { "content-type": "text/html;charset=UTF-8" },
+};
+const page500ResponseInit = {
+  status: 404,
+  headers: { "content-type": "text/html;charset=UTF-8" },
+};`
+  ).writeBlockStart(`export function match(method, pathname) {`).writeLines(
     `if (!pathname) {
     pathname = '/';
   } else if (pathname.charAt(0) !== '/') {
@@ -698,17 +708,10 @@ function renderRouter(routes, options = {
   }
   writer.writeBlockEnd("}").writeLines("return null;").writeBlockEnd("}");
   writer.write(`
-export async function invoke(route, request, platform, url = new URL(request.url)) {
-  const context = {
-    url,
-    request,
-    platform
-  };
-  const buildInput = createInput(context);
+export async function invoke(route, request, platform, url) {
+  const [context, buildInput] = createContext(route, request, platform, url);
 	try {
 		if (route) {
-			context.params = route.params;
-			context.meta = route.meta;
       try {
 				const response = await route.handler(context, buildInput);
 				if (response) return response;
@@ -723,14 +726,9 @@ export async function invoke(route, request, platform, url = new URL(request.url
   if (routes.special[RoutableFileTypes.NotFound]) {
     writer.write(
       `    } else {
-      context.params = {};
-      context.meta = {};
     }
     if (context.request.headers.get('Accept')?.includes('text/html')) {
-      return new Response(page404.stream(buildInput()), {
-        status: 404,
-        headers: { "content-type": "text/html;charset=UTF-8" },
-      });
+      return new Response(page404.stream(buildInput()), page404ResponseInit);
     }
 `
     );
@@ -742,13 +740,8 @@ export async function invoke(route, request, platform, url = new URL(request.url
   if (routes.special[RoutableFileTypes.Error]) {
     writer.writeBlockStart(
       `if (context.request.headers.get('Accept')?.includes('text/html')) {`
-    ).writeBlock(
-      `return new Response(page500.stream(buildInput({ error })), {`,
-      [
-        `status: 500,`,
-        `headers: { "content-type": "text/html;charset=UTF-8" },`
-      ],
-      `});`
+    ).writeLines(
+      `return new Response(page500.stream(buildInput({ error })), page500ResponseInit);`
     ).writeBlockEnd("}");
   }
   writer.writeLines(`throw error;`).writeBlockEnd("}").writeBlockEnd("}").write(`
@@ -984,8 +977,8 @@ function stripTsExtension(path3) {
   }
   return path3;
 }
-function renderRouteTypeInfo(routes, pathPrefix = ".", adapterTypes = "") {
-  var _a, _b;
+async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
+  var _a, _b, _c, _d;
   const writer = createStringWriter();
   writer.writeLines(
     `/*
@@ -993,28 +986,25 @@ function renderRouteTypeInfo(routes, pathPrefix = ".", adapterTypes = "") {
   Do NOT manually edit this file or your changes will be lost.
 */
 `,
-    `import type { HandlerLike, Route as AnyRoute, Context as AnyContext, ValidatePath, ValidateHref } from "@marko/run";`,
-    adapterTypes,
-    `
-
-declare global {
-  namespace MarkoRun {`
+    `import type { HandlerLike, Route as AnyRoute, Context as AnyContext, ParamsObject, ValidatePath, ValidateHref } from "@marko/run";`
   );
-  const pathsWriter = writer.branch("paths");
-  writer.write(`
-    type GetablePath<T extends string> = ValidatePath<GetPaths, T>;
-    type GetableHref<T extends string> = ValidateHref<GetPaths, T>; 
-    type PostablePath<T extends string> = ValidatePath<PostPaths, T>;
-    type PostableHref<T extends string> = ValidateHref<PostPaths, T>; 
+  let platformType = "unknown";
+  if (adapter && adapter.typeInfo) {
+    platformType = await adapter.typeInfo((data) => writer.write(data));
+    writer.writeLines("");
   }
-}
+  writer.writeLines(`
+interface NoParams extends ParamsObject {}
+interface NoMeta {}
 `);
+  const pathsWriter = writer.branch("paths");
   const routesWriter = writer.branch("types");
   const serverWriter = writer.branch("server");
   const middlewareRouteTypes = /* @__PURE__ */ new Map();
   const layoutRouteTypes = /* @__PURE__ */ new Map();
   const getPaths = /* @__PURE__ */ new Set();
   const postPaths = /* @__PURE__ */ new Set();
+  writeModuleDeclaration(serverWriter, void 0, void 0, platformType);
   for (const route of routes.list) {
     const { meta, handler, params, middleware, page, layouts } = route;
     const routeType = `Route${route.index}`;
@@ -1022,8 +1012,8 @@ declare global {
       /\/\$(\$?)([^\/]*)/,
       (_, catchAll, name) => catchAll ? `/:${name || "rest"}*` : `/:${name}`
     )}\``;
-    const paramsType = params ? renderParamsInfoType(params) : "{}";
-    let metaType = "undefined";
+    const paramsType = (params == null ? void 0 : params.length) ? renderParamsInfoType(params) : "NoParams";
+    let metaType = "NoMeta";
     if (page || handler) {
       const isGet = page || ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.includes("get"));
       const isPost = (_b = handler == null ? void 0 : handler.verbs) == null ? void 0 : _b.includes("post");
@@ -1043,31 +1033,31 @@ declare global {
       }
     }
     if (meta) {
-      metaType = `typeof import('${pathPrefix}/${stripTsExtension(
-        meta.relativePath
-      )}')`;
+      const path3 = stripTsExtension(`${pathPrefix}/${meta.relativePath}`);
+      metaType = `typeof import('${path3}')`;
       if (/\.(ts|js|mjs)$/.test(meta.relativePath)) {
         metaType += `['default']`;
       }
     }
     if (handler) {
-      writeRouteTypeModule(
+      writeModuleDeclaration(
         serverWriter,
-        pathPrefix,
-        handler.relativePath,
-        routeType
+        `${pathPrefix}/${handler.relativePath}`,
+        routeType,
+        platformType
       );
     }
     if (page) {
-      writer.writeLines(`
-declare module '${pathPrefix}/${page.relativePath}' {
-  export interface Input {}
-
-  namespace MarkoRun {
-    type Route = ${routeType};
-    type Context = AnyContext<AnyContext['platform'], Route>;
-  }
-}`);
+      writeModuleDeclaration(
+        writer,
+        `${pathPrefix}/${page.relativePath}`,
+        routeType,
+        platformType,
+        `
+  export interface Input {
+    renderBody: Marko.Body;
+  }`
+      );
     }
     if (middleware) {
       let i = 0;
@@ -1097,74 +1087,106 @@ declare module '${pathPrefix}/${page.relativePath}' {
       }
     }
     routesWriter.writeLines(
-      `interface ${routeType} extends AnyRoute<${paramsType}, ${metaType}, ${pathType}> {}`
+      `type ${routeType} = AnyRoute<${paramsType}, ${metaType}, ${pathType}>;`
     );
   }
-  pathsWriter.write("    type GetPaths =");
-  for (const path3 of getPaths) {
-    pathsWriter.write(`
-      | '${path3}'`);
+  pathsWriter.write(`type Get =`);
+  if (getPaths.size) {
+    for (const path3 of getPaths) {
+      pathsWriter.write(`
+  | '${path3}'`);
+    }
+  } else {
+    pathsWriter.write(" never");
   }
   pathsWriter.writeLines(";", "");
-  pathsWriter.write("    type PostPaths =");
-  for (const path3 of postPaths) {
-    pathsWriter.write(`
-      | '${path3}'`);
+  pathsWriter.write("type Post =");
+  if (postPaths.size) {
+    for (const path3 of postPaths) {
+      pathsWriter.write(`
+  | '${path3}'`);
+    }
+  } else {
+    pathsWriter.write(" never");
   }
-  pathsWriter.writeLines(";");
+  pathsWriter.writeLines(";", "");
   pathsWriter.join();
   for (const [file, { routeTypes }] of middlewareRouteTypes) {
-    writeRouteTypeModule(
+    writeModuleDeclaration(
       serverWriter,
-      pathPrefix,
-      file.relativePath,
-      routeTypes.join(" | ")
+      `${pathPrefix}/${file.relativePath}`,
+      routeTypes.join(" | "),
+      platformType
     );
   }
   for (const [file, { routeTypes }] of layoutRouteTypes) {
-    writer.writeLines(`
-declare module '${pathPrefix}/${file.relativePath}' {
+    writeModuleDeclaration(
+      writer,
+      `${pathPrefix}/${file.relativePath}`,
+      routeTypes.join(" | "),
+      platformType,
+      `
   export interface Input {
     renderBody: Marko.Body;
+  }`
+    );
   }
-
-  namespace MarkoRun {
-    type Route = ${routeTypes.join(" | ")};
-    type Context = AnyContext<AnyContext['platform'], Route>;
-  }
-}`);
+  if ((_c = routes.special["404"]) == null ? void 0 : _c.page) {
+    writeModuleDeclaration(
+      writer,
+      `${pathPrefix}/${routes.special["404"].page.relativePath}`,
+      void 0,
+      platformType,
+      `
+  export interface Input {}`
+    );
   }
-  for (const route of [routes.special["404"], routes.special["500"]]) {
-    if (route && route.page) {
-      writer.write(`
-declare module '${pathPrefix}/${route.page.relativePath}' {
-  export interface Input {`);
-      if (route.page.type === RoutableFileTypes.Error) {
-        writer.write(`
+  if ((_d = routes.special["500"]) == null ? void 0 : _d.page) {
+    writeModuleDeclaration(
+      writer,
+      `${pathPrefix}/${routes.special["500"].page.relativePath}`,
+      void 0,
+      platformType,
+      `
+  export interface Input {
     error: unknown;
-  `);
-      }
-      writer.writeLines(`}
-
-  namespace MarkoRun {
-    type Route = AnyRoute;
-    type Context = AnyContext<AnyContext['platform'], Route>;
-  }
-}`);
-    }
+  }`
+    );
   }
   serverWriter.join();
   return writer.end();
 }
-function writeRouteTypeModule(writer, pathPrefix, path3, routeType) {
-  writer.writeLines(`
-declare module '${pathPrefix}/${stripTsExtension(path3)}' {
+function writeModuleDeclaration(writer, path3 = "global", routeType = "AnyRoute", platformType = "unknown", moduleTypes) {
+  writer.writeLines("");
+  if (path3 === "global") {
+    writer.write("declare global {");
+  } else {
+    writer.write(`declare module '${stripTsExtension(path3)}' {`);
+  }
+  if (moduleTypes) {
+    writer.writeLines(moduleTypes);
+  }
+  const isMarko = path3.endsWith(".marko");
+  writer.write(`
   namespace MarkoRun {
+    type GetPaths = Get;
+    type PostPaths = Post;
+    type GetablePath<T extends string> = ValidatePath<Get, T>;
+    type GetableHref<T extends string> = ValidateHref<Get, T>; 
+    type PostablePath<T extends string> = ValidatePath<Post, T>;
+    type PostableHref<T extends string> = ValidateHref<Post, T>;
+    type Platform = ${platformType};`);
+  if (path3 !== "global") {
+    writer.write(`
     type Route = ${routeType};
-    type Context = AnyContext<AnyContext['platform'], Route>;
+    type Context = AnyContext<Platform, Route>${isMarko ? " & Marko.Global" : ""};
     type Handler<_Params = Route['params'], _Meta = Route['meta']> = HandlerLike<Route>;
     function route(handler: Handler): typeof handler;
     function route<_Params = Route['params'], _Meta = Route['meta']>(handler: Handler): typeof handler;
+    const NotHandled: unique symbol;
+    const NotMatched: unique symbol;`);
+  }
+  writer.writeLines(`
   }
 }`);
 }
@@ -1357,11 +1379,15 @@ var import_url = require("url");
 var import_meta = {};
 var __dirname = (0, import_url.fileURLToPath)(new URL(".", import_meta.url));
 var markoExt = ".marko";
+var POSIX_SEP = "/";
+var WINDOWS_SEP = "\\";
+var normalizePath = import_path2.default.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
 function isMarkoFile(id) {
   return id.endsWith(markoExt);
 }
-function markoServe(opts = {}) {
-  const { routesDir = "src/routes", adapter, ...markoOptions } = opts;
+function markoRun(opts = {}) {
+  let { routesDir = "src/routes", adapter, ...markoOptions } = opts;
+  let compiler;
   let store;
   let root;
   let resolvedRoutesDir;
@@ -1371,6 +1397,7 @@ function markoServe(opts = {}) {
   let tsConfigExists;
   let ssrEntryFiles;
   let devEntryFile;
+  let devEntryFilePosix;
   let devServer;
   let routes;
   let routeData;
@@ -1391,8 +1418,11 @@ function markoServe(opts = {}) {
       "{.tsconfig*,tsconfig*.json}"
     ))) {
       const filepath = import_path2.default.join(typesDir, "routes.d.ts");
-      const adapterTypeInfo = (adapter == null ? void 0 : adapter.writeTypeInfo) && await (adapter == null ? void 0 : adapter.writeTypeInfo());
-      const data = renderRouteTypeInfo(routes, import_path2.default.relative(typesDir, routesDir), adapterTypeInfo);
+      const data = await renderRouteTypeInfo(
+        routes,
+        import_path2.default.relative(typesDir, routesDir),
+        adapter
+      );
       if (data !== typesFile || !import_fs2.default.existsSync(filepath)) {
         await ensureDir(typesDir);
         await import_fs2.default.promises.writeFile(filepath, typesFile = data);
@@ -1405,24 +1435,30 @@ function markoServe(opts = {}) {
         route.handler.verbs = await extractVerbs(route.handler.filePath);
         if (!route.handler.verbs.length) {
           console.warn(
-            `Did not find any valid exports in middleware entry file:'${route.handler.filePath}' - expected to find any of 'get', 'post', 'put' or 'del'`
+            `Did not find any valid exports in middleware entry file:'${route.handler.filePath}' - expected to find any of 'GET', 'POST', 'PUT' or 'DELETE'`
           );
         }
       }
       if (route.page) {
         virtualFiles.set(
-          import_path2.default.join(root, `${markoRunFilePrefix}route__${route.key}.marko`),
+          import_path2.default.posix.join(
+            root,
+            `${markoRunFilePrefix}route__${route.key}.marko`
+          ),
           render ? renderRouteTemplate(route) : ""
         );
       }
       virtualFiles.set(
-        import_path2.default.join(root, `${markoRunFilePrefix}route__${route.key}.js`),
+        import_path2.default.posix.join(root, `${markoRunFilePrefix}route__${route.key}.js`),
         render ? renderRouteEntry(route) : ""
       );
     }
     for (const route of Object.values(routes.special)) {
       virtualFiles.set(
-        import_path2.default.join(root, `${markoRunFilePrefix}special__${route.key}.marko`),
+        import_path2.default.posix.join(
+          root,
+          `${markoRunFilePrefix}special__${route.key}.marko`
+        ),
         render ? renderRouteTemplate(route) : ""
       );
     }
@@ -1433,7 +1469,7 @@ function markoServe(opts = {}) {
       }) : ""
     );
     virtualFiles.set(
-      import_path2.default.join(root, `${markoRunFilePrefix}middleware.js`),
+      import_path2.default.posix.join(root, `${markoRunFilePrefix}middleware.js`),
       render ? renderMiddleware(routes.middleware) : ""
     );
   }
@@ -1462,25 +1498,36 @@ function markoServe(opts = {}) {
         if (externalPluginOptions) {
           opts = (0, import_vite.mergeConfig)(opts, externalPluginOptions);
         }
+        root = normalizePath(config2.root || process.cwd());
+        isBuild = env.command === "build";
+        isSSRBuild = isBuild && Boolean((_a = config2.build) == null ? void 0 : _a.ssr);
+        adapter = await resolveAdapter(root, opts, config2.logLevel !== "silent" && !isBuild || isSSRBuild);
         if (adapter) {
           const externalAdapterConfig = getExternalAdapterOptions(config2);
           if (externalAdapterConfig && adapter.configure) {
             adapter.configure(externalAdapterConfig);
           }
-          const adapterOptions = await ((_a = adapter.pluginOptions) == null ? void 0 : _a.call(adapter, opts));
+          const adapterOptions = await ((_b = adapter.pluginOptions) == null ? void 0 : _b.call(adapter, opts));
           if (adapterOptions) {
             opts = (0, import_vite.mergeConfig)(opts, adapterOptions);
           }
         }
-        root = (0, import_vite.normalizePath)(config2.root || process.cwd());
+        compiler ?? (compiler = await import(opts.compiler || "@marko/compiler"));
+        compiler.taglib.register("@marko/run", {
+          "<*>": {
+            template: import_path2.default.resolve(
+              __dirname,
+              "../components/src-attributes-transformer.cjs"
+            )
+          }
+        });
         store = opts.store || new import_vite2.FileStore(
           `marko-serve-vite-${import_crypto.default.createHash("SHA1").update(root).digest("hex")}`
         );
-        isBuild = env.command === "build";
-        isSSRBuild = isBuild && Boolean((_b = config2.build) == null ? void 0 : _b.ssr);
         resolvedRoutesDir = import_path2.default.resolve(root, routesDir);
         typesDir = import_path2.default.join(root, ".marko-run");
         devEntryFile = import_path2.default.join(root, "index.html");
+        devEntryFilePosix = normalizePath(devEntryFile);
         let pluginConfig = {
           logLevel: isBuild ? "warn" : void 0,
           define: isBuild ? {
@@ -1573,9 +1620,10 @@ function markoServe(opts = {}) {
             root,
             importee.slice(virtualFilePrefix.length + 1)
           );
-        } else if (!isBuild && importer === devEntryFile && importee.startsWith(`/${markoRunFilePrefix}`)) {
+        } else if (!isBuild && importer && (importer === devEntryFile || normalizePath(importer) === devEntryFilePosix) && importee.startsWith(`/${markoRunFilePrefix}`)) {
           importee = import_path2.default.resolve(root, "." + importee);
         }
+        importee = normalizePath(importee);
         if (isStale) {
           await buildVirtualFiles();
         }
@@ -1717,6 +1765,31 @@ async function ensureDir(dir) {
     await import_fs2.default.promises.mkdir(dir, { recursive: true });
   }
 }
+async function resolveAdapter(root, options, log) {
+  const { adapter } = options;
+  if (adapter !== void 0) {
+    return adapter;
+  }
+  const pkg = (0, import_vite.resolvePackageData)(".", root);
+  if (pkg) {
+    const dependecies = { ...pkg.data.dependecies, ...pkg.data.devDependencies };
+    for (const name of Object.keys(dependecies)) {
+      if (name.startsWith("@marko/run-adapter") || name.indexOf("marko-run-adapter") !== -1) {
+        try {
+          const module3 = await import(name);
+          log && console.log(`Using adapter ${name} listed in your package.json dependecies`);
+          return module3.default();
+        } catch (err) {
+          log && console.warn(`Attempt to use package '${name}' failed`, err);
+        }
+      }
+    }
+  }
+  const defaultAdapter = "@marko/run/adapter";
+  const module2 = await import(defaultAdapter);
+  log && console.log("Using default adapter");
+  return module2.default();
+}
 
 // src/vite/utils/server.ts
 var import_net = __toESM(require("net"), 1);