@hyperspan/framework 2.0.0-alpha.7 → 2.0.1

package/dist/fetch-handler.js

@@ -0,0 +1,108 @@
+import { createContext } from "./server.js";
+function compileRoutePath(path) {
+  const paramNames = [];
+  const isWildcard = path.endsWith("/*");
+  if (path === "/") {
+    return { pattern: /^\/$/, paramNames, isWildcard: false };
+  }
+  const segments = path.split("/").filter(Boolean);
+  const regexParts = segments.map((segment) => {
+    if (segment === "*") {
+      paramNames.push("...slug");
+      return "(.+)";
+    }
+    if (segment.startsWith(":")) {
+      paramNames.push(segment.slice(1));
+      return "([^/]+)";
+    }
+    return segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  });
+  const pattern = new RegExp(`^/${regexParts.join("/")}${isWildcard ? "" : "/?"}$`);
+  return { pattern, paramNames, isWildcard };
+}
+function mergeRouteMiddleware(server, route) {
+  route._serverConfig = server._config;
+  if (!server._middleware || !route._middleware) {
+    return;
+  }
+  for (const method of Object.keys(server._middleware)) {
+    if (Array.isArray(server._middleware[method]) && Array.isArray(route._middleware[method])) {
+      route._middleware[method] = server._middleware[method].concat(route._middleware[method]);
+    }
+  }
+}
+function matchRoute(compiledRoutes, pathname, method) {
+  for (const compiled of compiledRoutes) {
+    const match = pathname.match(compiled.pattern);
+    if (!match) {
+      continue;
+    }
+    const routeMethods = typeof compiled.route._methods === "function" ? compiled.route._methods() : ["*"];
+    const supportsMethod = routeMethods.includes(method) || routeMethods.includes("*") || method === "HEAD" && routeMethods.includes("GET");
+    if (!supportsMethod) {
+      continue;
+    }
+    const params = {};
+    compiled.paramNames.forEach((name, index) => {
+      const value = match[index + 1];
+      if (name.startsWith("...")) {
+        params[name] = value;
+      } else {
+        params[name] = value;
+      }
+    });
+    return { route: compiled.route, params };
+  }
+  return null;
+}
+function trailingSlashRedirect(pathname, request) {
+  if (pathname.length > 1 && pathname.endsWith("/")) {
+    const url = new URL(request.url);
+    url.pathname = pathname.slice(0, -1);
+    return Response.redirect(url.toString(), 308);
+  }
+  return null;
+}
+function createFetchHandler(server, options = {}) {
+  const compiledRoutes = server._routes.map((route) => {
+    const path = route._path();
+    mergeRouteMiddleware(server, route);
+    const { pattern, paramNames, isWildcard } = compileRoutePath(path);
+    return { route, pattern, paramNames, isWildcard };
+  });
+  compiledRoutes.sort((a, b) => {
+    const aSegments = a.route._path().split("/").filter(Boolean).length;
+    const bSegments = b.route._path().split("/").filter(Boolean).length;
+    return bSegments - aSegments;
+  });
+  return async (request) => {
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+    const method = request.method.toUpperCase();
+    const slashRedirect = trailingSlashRedirect(pathname, request);
+    if (slashRedirect) {
+      return slashRedirect;
+    }
+    const matched = matchRoute(compiledRoutes, pathname, method);
+    if (matched) {
+      request.params = matched.params;
+      return matched.route.fetch(request);
+    }
+    if (options.onNotMatched) {
+      const staticResponse = await options.onNotMatched(request);
+      if (staticResponse) {
+        return staticResponse;
+      }
+    }
+    return createContext(request).res.notFound();
+  };
+}
+function createApp(server, options = {}) {
+  const fetch = createFetchHandler(server, options);
+  return { fetch, server };
+}
+export {
+  compileRoutePath,
+  createApp,
+  createFetchHandler
+};

package/dist/html.js

@@ -0,0 +1 @@
+export * from "@hyperspan/html";

package/dist/index.js

@@ -0,0 +1,50 @@
+import {
+  createConfig,
+  createContext,
+  createRoute,
+  createServer,
+  initServerRoutes,
+  getRunnableRoute,
+  StreamResponse,
+  IS_PROD,
+  HTTPResponseException,
+  hyperspanDisableStreaming
+} from "./server.js";
+import { createFetchHandler, createApp, compileRoutePath } from "./fetch-handler.js";
+import {
+  setAssetManifest,
+  getAssetManifest,
+  resolveImport,
+  getRouteCss,
+  getImportMap,
+  registerImport
+} from "./client/manifest.js";
+import { buildClientJS, registerPathAliases } from "./client/js.js";
+import { registerRouteModule, registerRouteModules } from "./register-routes.js";
+import { renderIsland } from "./island.js";
+export {
+  HTTPResponseException,
+  IS_PROD,
+  StreamResponse,
+  buildClientJS,
+  compileRoutePath,
+  createApp,
+  createConfig,
+  createContext,
+  createFetchHandler,
+  createRoute,
+  createServer,
+  getAssetManifest,
+  getImportMap,
+  getRouteCss,
+  getRunnableRoute,
+  hyperspanDisableStreaming,
+  initServerRoutes,
+  registerImport,
+  registerPathAliases,
+  registerRouteModule,
+  registerRouteModules,
+  renderIsland,
+  resolveImport,
+  setAssetManifest
+};

package/dist/island.js

@@ -0,0 +1,17 @@
+import { html } from "./html.js";
+function renderIsland(Component, props = {}, options = { ssr: true }) {
+  if (!Component?.__HS_ISLAND?.render) {
+    const label = Component?.name ?? "Component";
+    throw new Error(
+      `${label} is not a Hyperspan island. Import it with \`with { island: 'preact' | 'svelte' | 'vue' }\` and ensure the matching plugin is listed in hyperspan.config.ts plugins.`
+    );
+  }
+  const result = Component.__HS_ISLAND.render(props, options);
+  if (result != null && typeof result.then === "function") {
+    return result.then((s) => html.raw(s));
+  }
+  return html.raw(result);
+}
+export {
+  renderIsland
+};

package/dist/layout.js

@@ -0,0 +1,42 @@
+var __freeze = Object.freeze;
+var __defProp = Object.defineProperty;
+var __template = (cooked, raw) => __freeze(__defProp(cooked, "raw", { value: __freeze(raw || cooked.slice()) }));
+var _a, _b;
+import { html } from "./html.js";
+import { CSS_PUBLIC_PATH } from "./client/css.js";
+import { getImportMap, getRouteCss } from "./client/manifest.js";
+import { actionsClient, streamingClient } from "./client/js.js";
+function hyperspanScriptTags() {
+  const imports = getImportMap();
+  const streamingPath = streamingClient.publicPath;
+  return html(_a || (_a = __template(['\n    <script type="importmap">\n      {"imports": ', `}
+    <\/script>
+    <script id="hyperspan-streaming-script">
+      // [Hyperspan] Streaming - Load the client streaming JS module only when the first chunk is loaded
+      window._hsc = window._hsc || [];
+      if (!window._hscInit) {
+        window._hscInit = true;
+        window._hsc.push = function (e) {
+          Array.prototype.push.call(window._hsc, e);
+          if (!window._hscLoading) {
+            window._hscLoading = true;
+            const script = document.createElement('script');
+            script.src = '`, "';\n            document.body.appendChild(script);\n          }\n        };\n      }\n    <\/script>\n  "])), imports, streamingPath);
+}
+function hyperspanStyleTags(context) {
+  const styleTags = [];
+  const cssImports = context.route.cssImports?.length ? context.route.cssImports : getRouteCss(context.route.path);
+  for (const cssFile of cssImports) {
+    const href = cssFile.startsWith("/") ? cssFile : `${CSS_PUBLIC_PATH}/${cssFile}`;
+    styleTags.push(html` <link rel="stylesheet" href="${href}" /> `);
+  }
+  return styleTags;
+}
+function hyperspanActionsScriptTag() {
+  return html(_b || (_b = __template(['<script type="module" src="', '"><\/script>'])), actionsClient.publicPath);
+}
+export {
+  hyperspanActionsScriptTag,
+  hyperspanScriptTags,
+  hyperspanStyleTags
+};

package/dist/middleware.js

@@ -0,0 +1,89 @@
+import { formDataToJSON } from "./utils.js";
+import { flattenError, prettifyError } from "zod";
+import { HTTPResponseException } from "./server.js";
+function inferValidationType(headers) {
+  const contentType = headers.get("content-type")?.toLowerCase() || "";
+  if (contentType.includes("application/json")) {
+    return "json";
+  } else if (contentType.includes("multipart/form-data")) {
+    return "form";
+  } else if (contentType.includes("application/x-www-form-urlencoded")) {
+    return "urlencoded";
+  }
+  return "json";
+}
+class ZodValidationError extends Error {
+  fieldErrors;
+  formErrors;
+  constructor(error, schema) {
+    const message = prettifyError(error);
+    const flattened = flattenError(error);
+    super(message);
+    this.name = "ZodValidationError";
+    this.fieldErrors = flattened.fieldErrors;
+    this.formErrors = flattened.formErrors;
+  }
+}
+function validateQuery(schema) {
+  return async (context, next) => {
+    const query = formDataToJSON(context.req.query);
+    const validated = schema.safeParse(query);
+    context.vars.query = validated.data;
+    if (!validated.success) {
+      const err = new ZodValidationError(validated.error, schema);
+      throw new HTTPResponseException(err, { status: 400 });
+    }
+    return next();
+  };
+}
+function validateBody(schema, type) {
+  return async (context, next) => {
+    const validationType = type || inferValidationType(context.req.headers);
+    let body = {};
+    if (validationType === "json") {
+      body = await context.req.raw.json();
+    } else if (validationType === "form") {
+      const formData = await context.req.formData();
+      body = formDataToJSON(formData);
+    } else if (validationType === "urlencoded") {
+      const urlencoded = await context.req.urlencoded();
+      body = formDataToJSON(urlencoded);
+    }
+    context.vars.body = body;
+    const validated = schema.safeParse(body);
+    if (!validated.success) {
+      const err = new ZodValidationError(validated.error, schema);
+      throw new HTTPResponseException(err, { status: 400 });
+    }
+    return next();
+  };
+}
+function isMiddlewareFunction(handler) {
+  return handler.length === 2;
+}
+async function executeMiddleware(context, handlers) {
+  if (handlers.length === 0) {
+    return context.res.notFound();
+  }
+  const createNext = (index) => {
+    return async () => {
+      if (index >= handlers.length) {
+        return context.res.notFound();
+      }
+      const handler = handlers[index];
+      if (isMiddlewareFunction(handler)) {
+        const next = createNext(index + 1);
+        const result = await handler(context, next);
+        return result instanceof Response ? result : context.res.html(String(result));
+      }
+      return await handler(context);
+    };
+  };
+  return await createNext(0)();
+}
+export {
+  ZodValidationError,
+  executeMiddleware,
+  validateBody,
+  validateQuery
+};

package/dist/register-routes.js

@@ -0,0 +1,41 @@
+import { getRunnableRoute } from "./server.js";
+import { isValidRoutePath, parsePath } from "./utils.js";
+function registerRouteModule(server, relativeFilePath, mod, manifest) {
+  if (!isValidRoutePath(relativeFilePath)) {
+    return null;
+  }
+  const route = getRunnableRoute(mod);
+  const parsedPath = parsePath(relativeFilePath);
+  let path = parsedPath.path;
+  if (typeof route._path === "function") {
+    const routePath = route._path();
+    if (routePath && routePath !== "/") path = routePath;
+  }
+  if (!route._config.path) {
+    route._config.path = path;
+    if (parsedPath.params.length > 0) {
+      const params = route._config.params ?? {};
+      parsedPath.params.forEach((param) => {
+        params[param] = void 0;
+      });
+      route._config.params = params;
+    }
+  }
+  if (manifest) {
+    const cssFiles = manifest.css?.[path] ?? manifest.css?.["*"];
+    if (cssFiles?.length) {
+      route._config.cssImports = cssFiles;
+    }
+  }
+  server._routes.push(route);
+  return route;
+}
+function registerRouteModules(server, modules, manifest) {
+  for (const { file, mod } of modules) {
+    registerRouteModule(server, file, mod, manifest);
+  }
+}
+export {
+  registerRouteModule,
+  registerRouteModules
+};