@hyperspan/framework 0.1.3 → 0.1.4

package/dist/server.d.ts

@@ -1,6 +1,6 @@
 // Generated by dts-bundle-generator v9.5.1
 
-import { Context, Handler, Hono } from 'hono';
+import { Context, Hono } from 'hono';
 
 declare class TmplHtml {
 	_kind: string;
@@ -15,84 +15,46 @@ declare class TmplHtml {
 	constructor(props: Pick<TmplHtml, "content" | "asyncContent">);
 }
 export declare const IS_PROD: boolean;
-/**
- * Route
- * Define a route that can handle a direct HTTP request
- * Route handlers should return a Response or TmplHtml object
- */
-export declare function createRoute(handler: Handler): HSRoute;
-/**
- * Component
- * Define a component or partial with an optional loading placeholder
- * These can be rendered anywhere inside other templates - even if async.
- */
-export declare function createComponent(render: () => THSComponentReturn | Promise<THSComponentReturn>): HSComponent;
-/**
- * Form + route handler
- * Automatically handles and parses form data
- *
- * INITIAL IDEA OF HOW THIS WILL WORK:
- * ---
- * 1. Renders component as initial form markup for GET request
- * 2. Bind form onSubmit function to custom client JS handling
- * 3. Submits form with JavaScript fetch()
- * 4. Replaces form content with content from server
- * 5. All validation and save logic is on the server
- * 6. Handles any Exception thrown on server as error displayed in client
- */
-export declare function createForm(renderForm: (data?: any) => THSResponseTypes, schema?: z.ZodSchema | null): HSFormRoute;
 /**
  * Types
  */
-export type THSComponentReturn = TmplHtml | string | number | null;
 export type THSResponseTypes = TmplHtml | Response | string | null;
-export declare const HS_DEFAULT_LOADING: () => TmplHtml;
-/**
- * Route handler helper
- */
-export declare class HSComponent {
-	_kind: string;
-	_handlers: Record<string, Handler>;
-	_loading?: () => TmplHtml;
-	render: () => THSComponentReturn | Promise<THSComponentReturn>;
-	constructor(render: () => THSComponentReturn | Promise<THSComponentReturn>);
-	loading(fn: () => TmplHtml): this;
-}
+export type THSRouteHandler = (context: Context) => THSResponseTypes | Promise<THSResponseTypes>;
 /**
- * Route handler helper
+ * Route
+ * Define a route that can handle a direct HTTP request
+ * Route handlers should return a Response or TmplHtml object
  */
-export declare class HSRoute {
+export declare function createRoute(handler?: THSRouteHandler): {
 	_kind: string;
-	_handlers: Record<string, Handler>;
-	_methods: null | string[];
-	constructor(handler: Handler);
-}
+	get(handler: THSRouteHandler): any;
+	post(handler: THSRouteHandler): any;
+	put(handler: THSRouteHandler): any;
+	delete(handler: THSRouteHandler): any;
+	patch(handler: THSRouteHandler): any;
+	run(method: string, context: Context): Promise<Response>;
+};
+export type THSRoute = ReturnType<typeof createRoute>;
 /**
- * Form route handler helper
+ * Create new API Route
+ * API Route handlers should return a JSON object or a Response
  */
-export type THSFormRenderer = (data?: any) => THSResponseTypes;
-export declare class HSFormRoute {
+export declare function createAPIRoute(handler?: THSRouteHandler): {
 	_kind: string;
-	_handlers: Record<string, Handler>;
-	_form: THSFormRenderer;
-	_methods: null | string[];
-	_schema: null | z.ZodSchema;
-	constructor(renderForm: THSFormRenderer, schema?: z.ZodSchema | null);
-	getDefaultData(): unknown;
-	/**
-	 * Get form renderer method
-	 */
-	renderForm(data?: any): THSResponseTypes;
-	get(handler: Handler): this;
-	patch(handler: Handler): this;
-	post(handler: Handler): this;
-	put(handler: Handler): this;
-	delete(handler: Handler): this;
-}
+	get(handler: THSRouteHandler): any;
+	post(handler: THSRouteHandler): any;
+	put(handler: THSRouteHandler): any;
+	delete(handler: THSRouteHandler): any;
+	patch(handler: THSRouteHandler): any;
+	run(method: string, context: Context): Promise<Response>;
+};
+export type THSAPIRoute = ReturnType<typeof createAPIRoute>;
 /**
- * Run route from file
+ * Get a Hyperspan runnable route from a module import
+ * @throws Error if no runnable route found
  */
-export declare function runFileRoute(RouteModule: any, context: Context): Promise<Response | false>;
+export declare function getRunnableRoute(route: unknown): THSRoute;
+export declare function isRouteRunnable(route: unknown): boolean;
 export type THSServerConfig = {
 	appDir: string;
 	staticFileRoot: string;
@@ -109,6 +71,10 @@ export type THSRouteMap = {
 	params: string[];
 };
 export declare function buildRoutes(config: THSServerConfig): Promise<THSRouteMap[]>;
+/**
+ * Run route from file
+ */
+export declare function createRouteFromModule(RouteModule: any): (context: Context) => Promise<Response>;
 /**
  * Create and start Bun HTTP server
  */

package/dist/server.js

@@ -1796,321 +1796,155 @@ var WSContext = class {
   }
 };
 
-// node_modules/@zod/core/dist/esm/core.js
-var $brand = Symbol("zod_brand");
-
-class $ZodAsyncError extends Error {
-  constructor() {
-    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+// node_modules/hono/dist/http-exception.js
+var HTTPException = class extends Error {
+  res;
+  status;
+  constructor(status = 500, options) {
+    super(options?.message, { cause: options?.cause });
+    this.res = options?.res;
+    this.status = status;
+  }
+  getResponse() {
+    if (this.res) {
+      const newResponse = new Response(this.res.body, {
+        status: this.status,
+        headers: this.res.headers
+      });
+      return newResponse;
+    }
+    return new Response(this.message, {
+      status: this.status
+    });
   }
-}
-var globalConfig = {};
-function config(config2) {
-  if (config2)
-    Object.assign(globalConfig, config2);
-  return globalConfig;
-}
+};
 
-// node_modules/@zod/core/dist/esm/util.js
-function jsonStringifyReplacer(_, value) {
-  if (typeof value === "bigint")
-    return value.toString();
-  return value;
-}
-function cached(getter) {
-  const set = false;
-  return {
-    get value() {
-      if (!set) {
-        const value = getter();
-        Object.defineProperty(this, "value", { value });
-        return value;
+// src/server.ts
+var IS_PROD = false;
+var CWD = process.cwd();
+function createRoute(handler) {
+  let _handlers = {};
+  if (handler) {
+    _handlers["GET"] = handler;
+  }
+  const api = {
+    _kind: "hsRoute",
+    get(handler2) {
+      _handlers["GET"] = handler2;
+      return api;
+    },
+    post(handler2) {
+      _handlers["POST"] = handler2;
+      return api;
+    },
+    put(handler2) {
+      _handlers["PUT"] = handler2;
+      return api;
+    },
+    delete(handler2) {
+      _handlers["DELETE"] = handler2;
+      return api;
+    },
+    patch(handler2) {
+      _handlers["PATCH"] = handler2;
+      return api;
+    },
+    async run(method, context) {
+      const handler2 = _handlers[method];
+      if (!handler2) {
+        throw new HTTPException(405, { message: "Method not allowed" });
+      }
+      const routeContent = await handler2(context);
+      if (routeContent instanceof Response) {
+        return routeContent;
+      }
+      const userIsBot = isbot(context.req.header("User-Agent"));
+      const streamOpt = context.req.query("__nostream");
+      const streamingEnabled = !userIsBot && (streamOpt !== undefined ? streamOpt : true);
+      const routeKind = typeof routeContent;
+      if (routeContent && routeKind === "object" && (routeContent instanceof TmplHtml || routeContent.constructor.name === "TmplHtml" || routeContent?._kind === "TmplHtml")) {
+        if (streamingEnabled) {
+          return new StreamResponse(renderStream(routeContent));
+        } else {
+          const output = await renderAsync(routeContent);
+          return context.html(output);
+        }
       }
-      throw new Error("cached value already set");
+      return context.text(String(routeContent));
     }
   };
+  return api;
 }
-var allowsEval = cached(() => {
-  try {
-    new Function("");
-    return true;
-  } catch (_) {
-    return false;
-  }
-});
-var propertyKeyTypes = new Set(["string", "number", "symbol"]);
-var primitiveTypes = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
-var NUMBER_FORMAT_RANGES = {
-  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
-  int32: [-2147483648, 2147483647],
-  uint32: [0, 4294967295],
-  float32: [-340282346638528860000000000000000000000, 340282346638528860000000000000000000000],
-  float64: [-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000]
-};
-function unwrapMessage(message) {
-  return typeof message === "string" ? message : message?.message;
-}
-function finalizeIssue(iss, ctx, config2) {
-  const full = { ...iss, path: iss.path ?? [] };
-  if (!iss.message) {
-    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
-    full.message = message;
-  }
-  delete full.inst;
-  delete full.continue;
-  if (!ctx?.reportInput) {
-    delete full.input;
-  }
-  return full;
-}
-
-// node_modules/@zod/core/dist/esm/errors.js
-var ZOD_ERROR = Symbol.for("{{zod.error}}");
-
-class $ZodError {
-  get message() {
-    return JSON.stringify(this.issues, jsonStringifyReplacer, 2);
-  }
-  constructor(issues) {
-    Object.defineProperty(this, "_tag", { value: ZOD_ERROR, enumerable: false });
-    Object.defineProperty(this, "name", { value: "$ZodError", enumerable: false });
-    this.issues = issues;
-  }
-  static [Symbol.hasInstance](inst) {
-    return inst?._tag === ZOD_ERROR;
-  }
-}
-function flattenError(error, mapper = (issue) => issue.message) {
-  const fieldErrors = {};
-  const formErrors = [];
-  for (const sub of error.issues) {
-    if (sub.path.length > 0) {
-      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
-      fieldErrors[sub.path[0]].push(mapper(sub));
-    } else {
-      formErrors.push(mapper(sub));
-    }
-  }
-  return { formErrors, fieldErrors };
-}
-function formatError(error, _mapper) {
-  const mapper = _mapper || function(issue) {
-    return issue.message;
-  };
-  const fieldErrors = { _errors: [] };
-  const processError = (error2) => {
-    for (const issue of error2.issues) {
-      if (issue.code === "invalid_union") {
-        issue.errors.map((issues) => processError({ issues }));
-      } else if (issue.code === "invalid_key") {
-        processError({ issues: issue.issues });
-      } else if (issue.code === "invalid_element") {
-        processError({ issues: issue.issues });
-      } else if (issue.path.length === 0) {
-        fieldErrors._errors.push(mapper(issue));
-      } else {
-        let curr = fieldErrors;
-        let i = 0;
-        while (i < issue.path.length) {
-          const el = issue.path[i];
-          const terminal = i === issue.path.length - 1;
-          if (!terminal) {
-            curr[el] = curr[el] || { _errors: [] };
-          } else {
-            curr[el] = curr[el] || { _errors: [] };
-            curr[el]._errors.push(mapper(issue));
-          }
-          curr = curr[el];
-          i++;
+function createAPIRoute(handler) {
+  let _handlers = {};
+  if (handler) {
+    _handlers["GET"] = handler;
+  }
+  const api = {
+    _kind: "hsRoute",
+    get(handler2) {
+      _handlers["GET"] = handler2;
+      return api;
+    },
+    post(handler2) {
+      _handlers["POST"] = handler2;
+      return api;
+    },
+    put(handler2) {
+      _handlers["PUT"] = handler2;
+      return api;
+    },
+    delete(handler2) {
+      _handlers["DELETE"] = handler2;
+      return api;
+    },
+    patch(handler2) {
+      _handlers["PATCH"] = handler2;
+      return api;
+    },
+    async run(method, context) {
+      const handler2 = _handlers[method];
+      if (!handler2) {
+        throw new Error("Method not allowed");
+      }
+      try {
+        const response = await handler2(context);
+        if (response instanceof Response) {
+          return response;
         }
+        return context.json({ meta: { success: true, dtResponse: new Date }, data: response }, { status: 200 });
+      } catch (err) {
+        const e = err;
+        console.error(e);
+        return context.json({
+          meta: { success: false, dtResponse: new Date },
+          data: {},
+          error: {
+            message: e.message,
+            stack: IS_PROD ? undefined : e.stack?.split(`
+`)
+          }
+        }, { status: 500 });
       }
     }
   };
-  processError(error);
-  return fieldErrors;
-}
-
-// node_modules/@zod/core/dist/esm/parse.js
-function _parse(schema, value, _ctx) {
-  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
-  if (result instanceof Promise) {
-    throw new $ZodAsyncError;
-  }
-  if (result.issues.length) {
-    throw new (this?.Error ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
-  }
-  return result.value;
+  return api;
 }
-
-// node_modules/zod/dist/esm/errors.js
-class ZodError extends $ZodError {
-  format(mapper) {
-    return formatError(this, mapper);
+function getRunnableRoute(route) {
+  if (isRouteRunnable(route)) {
+    return route;
   }
-  flatten(mapper) {
-    return flattenError(this, mapper);
+  const kind = typeof route;
+  if (kind === "function") {
+    return createRoute(route);
   }
-  addIssue(issue) {
-    this.issues.push(issue);
+  if (kind === "object" && "default" in route) {
+    return getRunnableRoute(route.default);
   }
-  addIssues(issues) {
-    this.issues.push(...issues);
-  }
-  get isEmpty() {
-    return this.issues.length === 0;
-  }
-}
-
-// node_modules/zod/dist/esm/parse.js
-var parse = /* @__PURE__ */ _parse.bind({ Error: ZodError });
-
-// src/server.ts
-var IS_PROD = false;
-var CWD = process.cwd();
-function createRoute(handler) {
-  return new HSRoute(handler);
+  throw new Error('Route not runnable. Use "export default createRoute()" to create a Hyperspan route.');
 }
-function createComponent(render2) {
-  return new HSComponent(render2);
-}
-function createForm(renderForm, schema) {
-  return new HSFormRoute(renderForm, schema);
-}
-var HS_DEFAULT_LOADING = () => html`<div>Loading...</div>`;
-
-class HSComponent {
-  _kind = "hsComponent";
-  _handlers = {};
-  _loading;
-  render;
-  constructor(render2) {
-    this.render = render2;
-  }
-  loading(fn) {
-    this._loading = fn;
-    return this;
-  }
-}
-
-class HSRoute {
-  _kind = "hsRoute";
-  _handlers = {};
-  _methods = null;
-  constructor(handler) {
-    this._handlers.GET = handler;
-  }
-}
-
-class HSFormRoute {
-  _kind = "hsFormRoute";
-  _handlers = {};
-  _form;
-  _methods = null;
-  _schema = null;
-  constructor(renderForm, schema = null) {
-    if (schema) {
-      this._form = renderForm;
-      this._schema = schema;
-    } else {
-      this._form = renderForm;
-    }
-    this._handlers.GET = () => renderForm(this.getDefaultData());
-  }
-  getDefaultData() {
-    if (!this._schema) {
-      return {};
-    }
-    const data = parse(this._schema, {});
-    return data;
-  }
-  renderForm(data) {
-    return this._form(data || this.getDefaultData());
-  }
-  get(handler) {
-    this._handlers.GET = handler;
-    return this;
-  }
-  patch(handler) {
-    this._handlers.PATCH = handler;
-    return this;
-  }
-  post(handler) {
-    this._handlers.POST = handler;
-    return this;
-  }
-  put(handler) {
-    this._handlers.PUT = handler;
-    return this;
-  }
-  delete(handler) {
-    this._handlers.DELETE = handler;
-    return this;
-  }
-}
-async function runFileRoute(RouteModule, context) {
-  const req = context.req;
-  const url = new URL(req.url);
-  const qs = url.searchParams;
-  const userIsBot = isbot(context.req.header("User-Agent"));
-  const streamOpt = qs.get("__nostream") ? !Boolean(qs.get("__nostream")) : undefined;
-  const streamingEnabled = !userIsBot && (streamOpt !== undefined ? streamOpt : true);
-  const RouteComponent = RouteModule.default;
-  const reqMethod = req.method.toUpperCase();
-  try {
-    if (RouteModule[reqMethod] !== undefined) {
-      return await runAPIRoute(RouteModule[reqMethod], context);
-    }
-    let routeContent;
-    if (!RouteComponent) {
-      throw new Error("No route was exported by default in matched route file.");
-    }
-    if (typeof RouteComponent._handlers !== "undefined") {
-      const routeMethodHandler = RouteComponent._handlers[reqMethod];
-      if (!routeMethodHandler) {
-        return new Response("Method Not Allowed", {
-          status: 405,
-          headers: { "content-type": "text/plain" }
-        });
-      }
-      routeContent = await routeMethodHandler(context);
-    } else {
-      routeContent = await RouteComponent(context);
-    }
-    if (routeContent instanceof Response) {
-      return routeContent;
-    }
-    let routeKind = typeof routeContent;
-    if (routeKind === "object" && (routeContent instanceof TmplHtml || routeContent.constructor.name === "TmplHtml" || routeContent?._kind === "TmplHtml")) {
-      if (streamingEnabled) {
-        return new StreamResponse(renderStream(routeContent));
-      } else {
-        const output = await renderAsync(routeContent);
-        return context.html(output);
-      }
-    }
-    console.log("Returning unknown type... ", routeContent);
-    return routeContent;
-  } catch (e) {
-    console.error(e);
-    return await showErrorReponse(context, e);
-  }
-}
-async function runAPIRoute(routeFn, context, middlewareResult) {
-  try {
-    return await routeFn(context, middlewareResult);
-  } catch (err) {
-    const e = err;
-    console.error(e);
-    return context.json({
-      meta: { success: false },
-      data: {
-        message: e.message,
-        stack: IS_PROD ? undefined : e.stack?.split(`
-`)
-      }
-    }, { status: 500 });
-  }
+function isRouteRunnable(route) {
+  return typeof route === "object" && "run" in route;
 }
 async function showErrorReponse(context, err) {
   const output = render(html`
@@ -2127,8 +1961,8 @@ async function showErrorReponse(context, err) {
   });
 }
 var ROUTE_SEGMENT = /(\[[a-zA-Z_\.]+\])/g;
-async function buildRoutes(config2) {
-  const routesDir = join(config2.appDir, "routes");
+async function buildRoutes(config) {
+  const routesDir = join(config.appDir, "routes");
   console.log(routesDir);
   const files = await readdir(routesDir, { recursive: true });
   const routes = [];
@@ -2163,11 +1997,27 @@ async function buildRoutes(config2) {
   }
   return routes;
 }
-async function createServer(config2) {
+function createRouteFromModule(RouteModule) {
+  return async (context) => {
+    const reqMethod = context.req.method.toUpperCase();
+    try {
+      const runnableRoute = getRunnableRoute(RouteModule);
+      const content = await runnableRoute.run(reqMethod, context);
+      if (content instanceof Response) {
+        return content;
+      }
+      return context.text(String(content));
+    } catch (e) {
+      console.error(e);
+      return await showErrorReponse(context, e);
+    }
+  };
+}
+async function createServer(config) {
   await Promise.all([buildClientJS(), buildClientCSS()]);
   const app = new Hono2;
-  config2.beforeRoutesAdded && config2.beforeRoutesAdded(app);
-  const fileRoutes = await buildRoutes(config2);
+  config.beforeRoutesAdded && config.beforeRoutesAdded(app);
+  const fileRoutes = await buildRoutes(config);
   const routeMap = [];
   for (let i = 0;i < fileRoutes.length; i++) {
     let route = fileRoutes[i];
@@ -2175,13 +2025,7 @@ async function createServer(config2) {
     const routePattern = normalizePath(route.route);
     routeMap.push({ route: routePattern, file: route.file });
     const routeModule = await import(fullRouteFile);
-    app.all(routePattern, async (context) => {
-      const matchedRoute = await runFileRoute(routeModule, context);
-      if (matchedRoute) {
-        return matchedRoute;
-      }
-      return context.notFound();
-    });
+    app.all(routePattern, createRouteFromModule(routeModule));
   }
   if (routeMap.length === 0) {
     app.get("/", (context) => {
@@ -2192,9 +2036,12 @@ async function createServer(config2) {
     console.log("[Hyperspan] File system routes (in app/routes):");
     console.table(routeMap);
   }
-  config2.afterRoutesAdded && config2.afterRoutesAdded(app);
+  config.afterRoutesAdded && config.afterRoutesAdded(app);
   app.use("*", serveStatic2({
-    root: config2.staticFileRoot
+    root: config.staticFileRoot,
+    onFound: IS_PROD ? (_, c) => {
+      c.header("Cache-Control", "public, max-age=2592000");
+    } : undefined
   }));
   app.notFound((context) => {
     return context.text("Not... found?", { status: 404 });
@@ -2209,8 +2056,9 @@ class StreamResponse extends Response {
     return new Response(stream, {
       status: 200,
       headers: {
-        "Content-Type": "text/html",
         "Transfer-Encoding": "chunked",
+        "Content-Type": "text/html; charset=UTF-8",
+        "Content-Encoding": "Identity",
         ...options?.headers ?? {}
       },
       ...options
@@ -2236,18 +2084,15 @@ function normalizePath(urlPath) {
   return (urlPath.endsWith("/") ? urlPath.substring(0, urlPath.length - 1) : urlPath).toLowerCase() || "/";
 }
 export {
-  runFileRoute,
   normalizePath,
+  isRouteRunnable,
+  getRunnableRoute,
   createServer,
+  createRouteFromModule,
   createRoute,
   createReadableStreamFromAsyncGenerator,
-  createForm,
-  createComponent,
+  createAPIRoute,
   buildRoutes,
   StreamResponse,
-  IS_PROD,
-  HS_DEFAULT_LOADING,
-  HSRoute,
-  HSFormRoute,
-  HSComponent
+  IS_PROD
 };