@marko/run 0.0.1-beta1

package/dist/adapters/static/server.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { type Server } from "http";
+export default function (dir?: string): Promise<Server>;

package/dist/cli/default.config.mjs

@@ -0,0 +1,7 @@
+import { defineConfig } from "vite";
+import marko from "@marko/run/vite";
+import staticAdapter from "@marko/run/adapter";
+
+export default defineConfig({
+  plugins: [marko({ adapter: staticAdapter() })],
+});

package/dist/cli/index.mjs

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+import { build as viteBuild, resolveConfig } from "vite";
+import sade from "sade";
+
+// src/vite/utils/config.ts
+var KEY = "__MARKO_SERVE_OPTIONS__";
+function getMarkoServeOptions(viteConfig) {
+  return viteConfig[KEY];
+}
+function setMarkoServeOptions(viteConfig, options) {
+  viteConfig[KEY] = options;
+  return viteConfig;
+}
+
+// src/cli/index.ts
+import { MemoryStore } from "@marko/vite";
+
+// src/vite/utils/server.ts
+import net from "net";
+import cp from "child_process";
+async function spawnServer(cmd, port = 0, cwd2 = process.cwd(), wait = 3e4) {
+  if (port <= 0) {
+    port = await getAvailablePort();
+  }
+  const proc = cp.spawn(cmd, {
+    cwd: cwd2,
+    shell: true,
+    stdio: "inherit",
+    windowsHide: true,
+    env: { NODE_ENV: "development", ...process.env, PORT: `${port}` }
+  });
+  const close = () => {
+    proc.unref();
+    proc.kill();
+  };
+  let remaining = wait > 0 ? wait : Infinity;
+  while (!await isPortInUse(port)) {
+    if (remaining >= 100) {
+      remaining -= 100;
+      await sleep(100);
+    } else {
+      close();
+      throw new Error(
+        `site-write: timeout while wating for server to start on port "${port}".`
+      );
+    }
+  }
+  return {
+    port,
+    close
+  };
+}
+async function isPortInUse(port) {
+  return new Promise((resolve) => {
+    const connection = net.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => done(false)).on("connect", () => done(true));
+    function done(connected) {
+      connection.end();
+      resolve(connected);
+    }
+  });
+}
+async function getAvailablePort() {
+  return new Promise((resolve) => {
+    const server = net.createServer().listen(0, () => {
+      const { port } = server.address();
+      server.close(() => resolve(port));
+    });
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/cli/index.ts
+var __dirname = fileURLToPath(new URL(".", import.meta.url));
+var cwd = process.cwd();
+var defaultPort = +process.env.PORT || 3e3;
+var prog = sade("marko-run").version("0.0.1").option("-c, --config", "Provide path to a Vite config");
+prog.command("preview [entry]", "", { default: true }).describe("Start production-like server against built assets").option("-o, --output", "Directory to serve files").option("-p, --port", "Port to use for dev server").option("-f, --file", "Output file to start").action(async (entry, opts) => {
+  const config = await getViteConfig(cwd, opts.config);
+  await build(entry, config, opts.output);
+  await preview(opts.entry, config, opts.port, opts.output);
+});
+prog.command("dev [entry]").describe("Start dev server").option("-p, --port", "Port to use for dev server").example("dev --config vite.config.js").action(async (entry, opts) => {
+  const cmd = opts._.length ? `${entry} ${opts._.join(" ")}` : entry ? `node ${entry}` : void 0;
+  const config = await getViteConfig(cwd, opts.config);
+  await dev(cmd, config, opts.port);
+});
+prog.command("build [entry]").describe("Build the application").option("-o, --output", "Directory to ouput built files").option("--skip-client", "Skip the client build").example("build --config vite.config.js").action(async (entry, opts) => {
+  const config = await getViteConfig(cwd, opts.config);
+  await build(entry, config, opts.ouput, opts["skip-client"]);
+});
+prog.parse(process.argv);
+async function preview(entry, configFile, port, outDir) {
+  const resolvedConfig = await resolveConfig(
+    { root: cwd, configFile, build: { outDir } },
+    "serve"
+  );
+  if (port === void 0) {
+    port = resolvedConfig.preview.port ?? defaultPort;
+  }
+  const adapter = await resolveAdapter(resolvedConfig);
+  if (!adapter) {
+    throw new Error("No adapter specified for serve command");
+  } else if (!adapter.startPreview) {
+    throw new Error(`Adapter ${adapter.name} does not support serve command`);
+  }
+  const dir = path.resolve(cwd, resolvedConfig.build.outDir);
+  const entryFile = entry ? path.join(dir, entry) : await findFileWithExt(dir, "index", [".mjs", ".js"]);
+  await adapter.startPreview(dir, entryFile, port);
+}
+async function dev(cmd, configFile, port) {
+  const resolvedConfig = await resolveConfig(
+    { root: cwd, configFile },
+    "build"
+  );
+  if (port === void 0) {
+    port = resolvedConfig.preview.port ?? defaultPort;
+  }
+  if (cmd) {
+    await spawnServer(cmd, port);
+  } else {
+    const adapter = await resolveAdapter(resolvedConfig);
+    if (!adapter) {
+      throw new Error(
+        "No adapter specified for dev command without custom target"
+      );
+    } else if (!adapter.startDev) {
+      throw new Error(`Adapter ${adapter.name} does not support serve command`);
+    } else {
+      await adapter.startDev(configFile, port);
+    }
+  }
+}
+async function build(entry, configFile, outDir, skipClient = false) {
+  var _a;
+  if (!entry) {
+    const resolvedConfig = await resolveConfig(
+      { root: cwd, configFile },
+      "build"
+    );
+    const adapter = await resolveAdapter(resolvedConfig);
+    if (!adapter) {
+      throw new Error("No adapter specified for build command without entry");
+    }
+    entry = await ((_a = adapter.getEntryFile) == null ? void 0 : _a.call(adapter));
+    if (!entry) {
+      throw new Error(
+        `Adapter ${adapter.name} does not support build command without entry`
+      );
+    }
+  }
+  const buildConfig = setMarkoServeOptions(
+    {
+      root: cwd,
+      configFile,
+      build: {
+        ssr: false,
+        outDir
+      }
+    },
+    {
+      store: new MemoryStore()
+    }
+  );
+  await viteBuild({
+    ...buildConfig,
+    build: {
+      ...buildConfig.build,
+      ssr: entry,
+      rollupOptions: {
+        output: {
+          entryFileNames: "index.mjs"
+        }
+      }
+    }
+  });
+  if (!skipClient) {
+    await viteBuild({
+      ...buildConfig,
+      build: {
+        ...buildConfig.build,
+        sourcemap: true
+      }
+    });
+  }
+}
+function findFileWithExt(dir, base, extensions = [".js", ".cjs", ".mjs", ".ts", ".mts"]) {
+  for (const ext of extensions) {
+    const filePath = path.join(dir, base + ext);
+    if (fs.existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return void 0;
+}
+async function getViteConfig(dir, configFile, bases = ["serve.config", "vite.config"]) {
+  if (configFile) {
+    if (!fs.existsSync(path.join(dir, configFile))) {
+      throw new Error(`Unable to load config file '${configFile}' from ${dir}`);
+    }
+    return configFile;
+  }
+  for (const base of bases) {
+    configFile = findFileWithExt(dir, base);
+    if (configFile) {
+      return configFile;
+    }
+  }
+  return path.join(__dirname, "default.config.mjs");
+}
+async function resolveAdapter(config) {
+  const options = getMarkoServeOptions(config);
+  if (!options) {
+    throw new Error("Unable to resolve Marko Serve options");
+  }
+  return options.adapter;
+}

package/dist/runtime/index.cjs

@@ -0,0 +1,34 @@
+"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/index.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  getMatchedRoute: () => import_router.getMatchedRoute,
+  handler: () => import_router.handler,
+  router: () => import_router.router
+});
+module.exports = __toCommonJS(runtime_exports);
+var import_router = require("@marko/run/router");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMatchedRoute,
+  handler,
+  router
+});

package/dist/runtime/index.d.ts

@@ -0,0 +1,2 @@
+export { router, getMatchedRoute, handler } from '@marko/run/router';
+export type { MatchedRoute, Handler, RouteContext, RouteHandler, RouteMatcher, Router } from './types';

package/dist/runtime/index.js

@@ -0,0 +1,7 @@
+// src/runtime/index.ts
+import { router, getMatchedRoute, handler } from "@marko/run/router";
+export {
+  getMatchedRoute,
+  handler,
+  router
+};

package/dist/runtime/request.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import type { ServerResponse, IncomingMessage } from "http";
+export declare function createWebRequest<NodeRequest extends IncomingMessage = IncomingMessage>(nodeRequest: NodeRequest, url: URL): Request;
+export declare function applyWebResponse<NodeRequest extends IncomingMessage = IncomingMessage>(nodeResponse: ServerResponse<NodeRequest>, webResponse: Response): Promise<void>;

package/dist/runtime/router.cjs

@@ -0,0 +1,39 @@
+"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/router.ts
+var router_exports = {};
+__export(router_exports, {
+  getMatchedRoute: () => getMatchedRoute,
+  handler: () => handler,
+  router: () => router
+});
+module.exports = __toCommonJS(router_exports);
+function notImplemented() {
+  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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMatchedRoute,
+  handler,
+  router
+});

package/dist/runtime/router.d.ts

@@ -0,0 +1,4 @@
+import type { Handler, RouteMatcher, Router } from './types';
+export declare const handler: Handler;
+export declare const router: Router;
+export declare const getMatchedRoute: RouteMatcher;

package/dist/runtime/router.js

@@ -0,0 +1,12 @@
+// src/runtime/router.ts
+function notImplemented() {
+  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;
+export {
+  getMatchedRoute,
+  handler,
+  router
+};

package/dist/runtime/types.d.ts

@@ -0,0 +1,22 @@
+import type { AdapterRequestContext } from '@hattip/core';
+export interface RouteContext<Params extends Record<string, string> = {}, Meta = unknown> {
+    request: Request;
+    url: URL;
+    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 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;
+}

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

@@ -0,0 +1,5 @@
+import type { Route, BuiltRoutes, CodegenOptions } from "../types";
+export declare const DefaultCodegenOptions: CodegenOptions;
+export declare function renderRouteTemplate(route: Route): string;
+export declare function renderRouteEntry(route: Route): string;
+export declare function renderRouter(routes: BuiltRoutes, options?: CodegenOptions): string;

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

@@ -0,0 +1,20 @@
+export interface Writer {
+    indent: number;
+    branch(name: string): Writer;
+    join(closeBranches?: boolean): void;
+    write(data: string): Writer;
+    writeLines(...lines: string[]): Writer;
+    writeBlockStart(data: string): Writer;
+    writeBlockEnd(data: string): Writer;
+    writeBlock(start: string, lines: string[], end: string): Writer;
+}
+export interface WriterOptions {
+    indentWith?: string;
+    onJoin?: (writer: Writer) => void;
+}
+export declare function createWriter(sink: (data: string) => void, options?: WriterOptions): Writer;
+interface StringWriter extends Writer {
+    end(): string;
+}
+export declare function createStringWriter(opts?: WriterOptions): StringWriter;
+export {};

package/dist/vite/constants.d.ts

@@ -0,0 +1,19 @@
+declare type ValuesOf<T> = T[keyof T];
+export declare const markoServeFilePrefix = "__marko-serve__";
+export declare const virtualFilePrefix = "virtual:marko-serve";
+export declare const virtualRoutesPrefix: string;
+export declare const httpVerbs: readonly ["get", "post", "put", "delete"];
+export declare const serverEntryQuery = "?marko-server-entry";
+export declare const browserEntryQuery = "?marko-browser-entry";
+export declare const RoutableFileTypes: {
+    readonly Page: "page";
+    readonly Layout: "layout";
+    readonly Handler: "handler";
+    readonly Middleware: "middleware";
+    readonly Meta: "meta";
+    readonly NotFound: "404";
+    readonly Error: "500";
+};
+export declare type RoutableFileType = ValuesOf<typeof RoutableFileTypes>;
+export declare type HttpVerb = typeof httpVerbs[number];
+export {};