hono

MoonBit bindings for Hono, a fast and lightweight web framework.

#Installation

moon add mizchi/js
moon add mizchi/npm_typed
npm install hono

Add to your moon.pkg:

import {
  "mizchi/js",
  "mizchi/js_core" @core,
  "mizchi/js_web/http",
  "mizchi/npm_typed/hono",
}

#Features

Hono core (routing, middleware, context)
JSX rendering (hono/jsx)
CSS-in-JS (hono/css)
Cookie helpers (hono/cookie)
JWT helpers (hono/jwt)
CORS middleware (hono/cors)
RPC client (hono/client)
Testing utilities (hono/testing)

#Usage

#Basic Example

async fn main {
  let app : @hono.Hono[Unit, Unit] = @hono.Hono::new()
  app.get("/", fn(c) { c.text("Hello, Hono!") }) |> ignore
  // serve with @hono/node-server or deploy to Cloudflare Workers
}

#JSX with HonoJsx (Recommended)

For ESM environments, use the HonoJsx API which handles module initialization automatically:

async fn create_app() -> @hono.Hono[Unit, Unit] {
  let hono_jsx = @hono.import_hono_jsx()
  let hono_css = @hono.import_hono_css()

  let app = @hono.Hono::new()
  app.get("/", fn(c) {
    let content = hono_jsx.jsx("div", [
      hono_jsx.jsx("h1", ["Hello, World!"]),
    ])
    c.html_jsx(content)
  })
}

#JSX with Legacy API

The legacy API (jsx, h, fragment) is simpler but requires initialization in ESM:

async fn create_app() -> @hono.Hono[Unit, Unit] {
  // Required for ESM: initialize Fragment before using fragment()
  @hono.init_jsx_runtime()

  let app = @hono.Hono::new()
  app.get("/", fn(c) {
    let content = @hono.jsx("div", [
      @hono.jsx("h1", ["Hello, World!"]),
    ])
    c.html_jsx(content)
  })
}

#ESM Migration Notes

This package uses #module directive for ESM compatibility. Most functions work automatically, but Fragment requires special handling because it's a value export (not a function).

#Why init_jsx_runtime() is needed

#module directive only works with function exports
Fragment is a Symbol value exported from hono/jsx/jsx-runtime
init_jsx_runtime() dynamically imports and stores Fragment in globalThis

#Recommendation

For new code, prefer the HonoJsx API which encapsulates all initialization:

let hono_jsx = @hono.import_hono_jsx()
hono_jsx.fragment([child1, child2])  // No manual init needed

#Example

See src/examples/hono_app for a complete example with:

Routing
JSX rendering
CSS-in-JS styling
Cookie-based authentication
CORS middleware

FC

source

type FC[T] = (T) -> JSXNode

Component function type

Handler

source

type Handler[Env, ExecutionContext] = async (Context[Env, ExecutionContext]) -> @mizchi/js_web/http.Response
Response

Handler function type: (Context) -> Response | Promise[Response]

Middleware

source

type Middleware[Env, ExecutionContext] = (Context[Env, ExecutionContext], () -> @mizchi/js_core.Promise
Promise[@mizchi/js_web/http.Response
Response]) -> @mizchi/js_core.Promise
Promise[@mizchi/js_web/http.Response
Response]

Middleware function type

CssClassName

source

pub trait CssClassName {
  fn value(Self) -> @mizchi/js_core.Any
Any
}

CSS class name trait - accepts String or CssClass Used for jsx class attribute

impl CssClassName for String

HonoNode

source

pub trait HonoNode {
  fn toHonoNode(Self) -> @mizchi/js_core.Any
Any
}

HonoNode trait for JSX children

impl HonoNode for Bool

impl HonoNode for Int

impl HonoNode for Double

impl HonoNode for String

impl HonoNode for Array[T]

ClientEndpoint

source

pub type ClientEndpoint

ClientEndpoint represents a path endpoint that can be called with HTTP methods

ClientEndpoint::as_any

source

fn ClientEndpoint::as_any(self : ClientEndpoint) -> @mizchi/js_core.Any
Any

ClientEndpoint::delete_

source

async fn ClientEndpoint::delete_(self : ClientEndpoint, query? : @mizchi/js_core.Any
Any, form? : @mizchi/js_core.Any
Any, json? : @mizchi/js_core.Any
Any, param? : @mizchi/js_core.Any
Any, header? : @mizchi/js_core.Any
Any, init? : @mizchi/js_core.Any
Any) -> ClientResponse

Make a DELETE request to the endpoint Original: endpoint.$delete(options)

ClientEndpoint::get_

source

async fn ClientEndpoint::get_(self : ClientEndpoint, query? : @mizchi/js_core.Any
Any, form? : @mizchi/js_core.Any
Any, json? : @mizchi/js_core.Any
Any, param? : @mizchi/js_core.Any
Any, header? : @mizchi/js_core.Any
Any, init? : @mizchi/js_core.Any
Any) -> ClientResponse

Make a GET request to the endpoint Original: endpoint.$get(options)

ClientEndpoint::patch_

source

async fn ClientEndpoint::patch_(self : ClientEndpoint, query? : @mizchi/js_core.Any
Any, form? : @mizchi/js_core.Any
Any, json? : @mizchi/js_core.Any
Any, param? : @mizchi/js_core.Any
Any, header? : @mizchi/js_core.Any
Any, init? : @mizchi/js_core.Any
Any) -> ClientResponse

Make a PATCH request to the endpoint Original: endpoint.$patch(options)

ClientEndpoint::post_

source

async fn ClientEndpoint::post_(self : ClientEndpoint, query? : @mizchi/js_core.Any
Any, form? : @mizchi/js_core.Any
Any, json? : @mizchi/js_core.Any
Any, param? : @mizchi/js_core.Any
Any, header? : @mizchi/js_core.Any
Any, init? : @mizchi/js_core.Any
Any) -> ClientResponse

Make a POST request to the endpoint Original: endpoint.$post(options)

ClientEndpoint::put_

source

async fn ClientEndpoint::put_(self : ClientEndpoint, query? : @mizchi/js_core.Any
Any, form? : @mizchi/js_core.Any
Any, json? : @mizchi/js_core.Any
Any, param? : @mizchi/js_core.Any
Any, header? : @mizchi/js_core.Any
Any, init? : @mizchi/js_core.Any
Any) -> ClientResponse

Make a PUT request to the endpoint Original: endpoint.$put(options)

ClientEndpoint::url_

source

fn ClientEndpoint::url_(self : ClientEndpoint, query? : @mizchi/js_core.Any
Any, form? : @mizchi/js_core.Any
Any, json? : @mizchi/js_core.Any
Any, param? : @mizchi/js_core.Any
Any, header? : @mizchi/js_core.Any
Any, init? : @mizchi/js_core.Any
Any) -> String

Get the URL for the endpoint Original: endpoint.$url(options)

ClientResponse

source

pub type ClientResponse

ClientResponse type wrapping Response

ClientResponse::arrayBuffer

source

#alias(array_buffer)
async fn ClientResponse::arrayBuffer(self : ClientResponse) -> @mizchi/js_core.Any
Any

Parse response as array buffer

ClientResponse::as_any

source

fn ClientResponse::as_any(self : ClientResponse) -> @mizchi/js_core.Any
Any

ClientResponse::blob

source

async fn ClientResponse::blob(self : ClientResponse) -> @mizchi/js_core.Any
Any

Parse response as blob

ClientResponse::headers

source

fn ClientResponse::headers(self : ClientResponse) -> @mizchi/js_core.Any
Any

Get headers from response

ClientResponse::json

source

async fn ClientResponse::json(self : ClientResponse) -> @mizchi/js_core.Any
Any

Parse response as JSON

ClientResponse::ok

source

fn ClientResponse::ok(self : ClientResponse) -> Bool

Check if response is ok

ClientResponse::status

source

fn ClientResponse::status(self : ClientResponse) -> Int

Get response status

ClientResponse::text

source

async fn ClientResponse::text(self : ClientResponse) -> String

Parse response as text

Context

source

pub(all) struct Context[Env, ExecutionContext] {
  req : HonoRequest
  env : Env
  executionCtx : ExecutionContext
}

Context object passed to handlers Type parameters: Env (environment bindings), ExecutionContext

Context::as_any

source

fn[Env, ExecutionContext] Context::as_any(self : Context[Env, ExecutionContext]) -> @mizchi/js_core.Any
Any

Context::body

source

fn[Env, ExecutionContext] Context::body(self : Context[Env, ExecutionContext], body : String, status? : Int, headers? : @mizchi/js_core.Any
Any) -> @mizchi/js_web/http.Response
Response

Return a Response with body https://hono.dev/docs/api/context#body

Context::executionCtx

source

#alias(execution_ctx)
fn[Env, ExecutionContext] Context::executionCtx(self : Context[Env, ExecutionContext]) -> ExecutionContext

Get execution context (c.executionCtx) Alias for executionCtx field

Context::getValue

source

#alias(get_value)
fn[Env, ExecutionContext] Context::getValue(self : Context[Env, ExecutionContext], key : String) -> @mizchi/js_core.Any
Any

Get a value from context

Context::header

source

fn[Env, ExecutionContext] Context::header(self : Context[Env, ExecutionContext], name : String, value : String) -> Unit

Set response header https://hono.dev/docs/api/context#header

Context::html

source

fn[Env, ExecutionContext] Context::html(self : Context[Env, ExecutionContext], html : String, status? : Int) -> @mizchi/js_web/http.Response
Response

Return HTML response https://hono.dev/docs/api/context#html

Context::html_jsx

source

fn[Env, ExecutionContext] Context::html_jsx(self : Context[Env, ExecutionContext], node : JSXNode, status? : Int) -> @mizchi/js_web/http.Response
Response

Extend Context with JSX html method

Context::json

source

fn[Env, ExecutionContext, T] Context::json(self : Context[Env, ExecutionContext], data : T, status? : Int) -> @mizchi/js_web/http.Response
Response

Return JSON response https://hono.dev/docs/api/context#json

Context::notFound

source

#alias(not_found)
fn[Env, ExecutionContext] Context::notFound(self : Context[Env, ExecutionContext]) -> @mizchi/js_web/http.Response
Response

Return 404 Not Found https://hono.dev/docs/api/context#notfound

Context::redirect

source

fn[Env, ExecutionContext] Context::redirect(self : Context[Env, ExecutionContext], url : String, status? : Int) -> @mizchi/js_web/http.Response
Response

Redirect to URL https://hono.dev/docs/api/context#redirect

Context::render

source

fn[Env, ExecutionContext] Context::render(self : Context[Env, ExecutionContext], content : String) -> @mizchi/js_web/http.Response
Response

Render content using the renderer set by setRenderer https://hono.dev/docs/api/context#render-setrenderer

Context::res

source

fn[Env, ExecutionContext] Context::res(self : Context[Env, ExecutionContext]) -> @mizchi/js_web/http.Response
Response

Get the Response object https://hono.dev/docs/api/context#res

Context::set

source

fn[Env, ExecutionContext] Context::set(self : Context[Env, ExecutionContext], key : String, value : @mizchi/js_core.Any
Any) -> Unit

Set a value in context https://hono.dev/docs/api/context#set-get

Context::setRenderer

source

#alias(set_renderer)
fn[Env, ExecutionContext] Context::setRenderer(self : Context[Env, ExecutionContext], renderer : (String) -> @mizchi/js_web/http.Response
Response) -> Unit

Set a custom renderer for templates https://hono.dev/docs/api/context#setrenderer

Context::status

source

fn[Env, ExecutionContext] Context::status(self : Context[Env, ExecutionContext], code : Int) -> Unit

Set status code https://hono.dev/docs/api/context#status

Context::stream_jsx

source

async fn[Env, ExecutionContext] Context::stream_jsx(self : Context[Env, ExecutionContext], hono_jsx : HonoJsx, node : JSXNode, status? : Int) -> @mizchi/js_web/http.Response
Response

Extend Context with streaming JSX response

Context::text

source

fn[Env, ExecutionContext] Context::text(self : Context[Env, ExecutionContext], text : String, status? : Int) -> @mizchi/js_web/http.Response
Response

Return text response https://hono.dev/docs/api/context#text

Context::var_

source

fn[Env, ExecutionContext] Context::var_(self : Context[Env, ExecutionContext], key : String) -> @mizchi/js_core.Any
Any

Get a variable from context https://hono.dev/docs/api/context#var

CorsMiddleware

source

#external
pub type CorsMiddleware

CORS middleware type

CorsMiddleware::as_any

source

fn CorsMiddleware::as_any(self : CorsMiddleware) -> @mizchi/js_core.Any
Any

CssClass

source

#external
pub type CssClass

CSS class - wraps the JS css object to preserve callbacks for Style component

impl CssClassName for CssClass

CssClass::as_any

source

fn CssClass::as_any(self : CssClass) -> @mizchi/js_core.Any
Any

CssClass::to_string

source

fn CssClass::to_string(self : CssClass) -> String

Get the class name string from CssClass

Hono

source

#external
pub type Hono[Env, ExecutionContext]

Hono application instance Type parameters: Env (environment bindings), ExecutionContext

Hono::all

source

fn[Env, ExecutionContext] Hono::all(self : Hono[Env, ExecutionContext], path : String, handler : async (Context[Env, ExecutionContext]) -> @mizchi/js_web/http.Response
Response) -> Hono[Env, ExecutionContext]

ALL method handler

Hono::as_any

source

fn[Env, ExecutionContext] Hono::as_any(self : Hono[Env, ExecutionContext]) -> @mizchi/js_core.Any
Any

Hono::basePath

source

#alias(base_path)
fn[Env, ExecutionContext] Hono::basePath(self : Hono[Env, ExecutionContext], path : String) -> Hono[Env, ExecutionContext]

Set base path https://hono.dev/docs/api/hono#basepath

Hono::cors

source

fn[Env, ExecutionContext] Hono::cors(self : Hono[Env, ExecutionContext], path : String, origin? : String, allowMethods? : Array[String], allowHeaders? : Array[String], maxAge? : Int, credentials? : Bool, exposeHeaders? : Array[String]) -> Hono[Env, ExecutionContext]

Apply CORS middleware to Hono app for a specific path

Hono::cors_all

source

fn[Env, ExecutionContext] Hono::cors_all(self : Hono[Env, ExecutionContext], origin? : String, allowMethods? : Array[String], allowHeaders? : Array[String], maxAge? : Int, credentials? : Bool, exposeHeaders? : Array[String]) -> Hono[Env, ExecutionContext]

Apply CORS middleware to all paths

Hono::delete

source

fn[Env, ExecutionContext] Hono::delete(self : Hono[Env, ExecutionContext], path : String, handler : async (Context[Env, ExecutionContext]) -> @mizchi/js_web/http.Response
Response) -> Hono[Env, ExecutionContext]

DELETE route handler

Hono::fetch

source

fn[Env, ExecutionContext] Hono::fetch(self : Hono[Env, ExecutionContext], request : @mizchi/js_web/http.Request
Request) -> @mizchi/js_core.Promise
Promise[@mizchi/js_web/http.Response
Response]

Handle requests https://hono.dev/docs/api/hono#fetch

Hono::fire

source

fn[Env, ExecutionContext] Hono::fire(self : Hono[Env, ExecutionContext]) -> Hono[Env, ExecutionContext]

Fire requests (for testing) https://hono.dev/docs/api/hono#fire

Hono::get

source

fn[Env, ExecutionContext] Hono::get(self : Hono[Env, ExecutionContext], path : String, handler : async (Context[Env, ExecutionContext]) -> @mizchi/js_web/http.Response
Response) -> Hono[Env, ExecutionContext]

GET route handler https://hono.dev/docs/api/hono#get-post-put-delete

Hono::mount

source

fn[Env, ExecutionContext] Hono::mount(self : Hono[Env, ExecutionContext], path : String, app : Hono[Env, ExecutionContext]) -> Hono[Env, ExecutionContext]

Mount another application https://hono.dev/docs/api/hono#mount

Hono::new

source

async fn[Env, ExecutionContext] Hono::new(strict? : Bool) -> Hono[Env, ExecutionContext]

Create a new Hono instance (async) Example with strict mode disabled:

let app = Hono::new()

let app_strict = Hono::new(strict=false)

Hono::notFound

source

#alias(not_found)
fn[Env, ExecutionContext] Hono::notFound(self : Hono[Env, ExecutionContext], handler : async (Context[Env, ExecutionContext]) -> @mizchi/js_web/http.Response
Response) -> Hono[Env, ExecutionContext]

Custom 404 handler https://hono.dev/docs/api/hono#notfound

Hono::onError

source

#alias(on_error)
fn[Env, ExecutionContext] Hono::onError(self : Hono[Env, ExecutionContext], handler : (@mizchi/js_core.Any
Any, Context[Env, ExecutionContext]) -> @mizchi/js_web/http.Response
Response) -> Hono[Env, ExecutionContext]

Error handler https://hono.dev/docs/api/hono#onerror

Hono::options

source

fn[Env, ExecutionContext] Hono::options(self : Hono[Env, ExecutionContext], path : String, handler : async (Context[Env, ExecutionContext]) -> @mizchi/js_web/http.Response
Response) -> Hono[Env, ExecutionContext]

OPTIONS route handler

Hono::patch

source

fn[Env, ExecutionContext] Hono::patch(self : Hono[Env, ExecutionContext], path : String, handler : async (Context[Env, ExecutionContext]) -> @mizchi/js_web/http.Response
Response) -> Hono[Env, ExecutionContext]

PATCH route handler

Hono::post

source

fn[Env, ExecutionContext] Hono::post(self : Hono[Env, ExecutionContext], path : String, handler : async (Context[Env, ExecutionContext]) -> @mizchi/js_web/http.Response
Response) -> Hono[Env, ExecutionContext]

POST route handler

Hono::put

source

fn[Env, ExecutionContext] Hono::put(self : Hono[Env, ExecutionContext], path : String, handler : async (Context[Env, ExecutionContext]) -> @mizchi/js_web/http.Response
Response) -> Hono[Env, ExecutionContext]

PUT route handler

Hono::route

source

fn[Env, ExecutionContext] Hono::route(self : Hono[Env, ExecutionContext], path : String, app : Hono[Env, ExecutionContext]) -> Hono[Env, ExecutionContext]

Route grouping https://hono.dev/docs/api/hono#route

Hono::use_

source

fn[Env, ExecutionContext] Hono::use_(self : Hono[Env, ExecutionContext], path : String, middleware : (Context[Env, ExecutionContext], () -> @mizchi/js_core.Promise
Promise[@mizchi/js_web/http.Response
Response]) -> @mizchi/js_core.Promise
Promise[@mizchi/js_web/http.Response
Response]) -> Hono[Env, ExecutionContext]

Apply middleware https://hono.dev/docs/api/hono#use

Hono::useall

source

fn[Env, ExecutionContext] Hono::useall(self : Hono[Env, ExecutionContext], middleware : (Context[Env, ExecutionContext], () -> @mizchi/js_core.Promise
Promise[@mizchi/js_web/http.Response
Response]) -> @mizchi/js_core.Promise
Promise[@mizchi/js_web/http.Response
Response]) -> Hono[Env, ExecutionContext]

Apply middleware to all paths

HonoClient

source

pub type HonoClient

HonoClient type for making RPC requests

HonoClient::as_any

source

fn HonoClient::as_any(self : HonoClient) -> @mizchi/js_core.Any
Any

HonoClient::path

source

fn HonoClient::path(self : HonoClient, path : String) -> ClientEndpoint

Access a path on the client Original: client[path] or client.path

HonoContext

source

#external
pub type HonoContext[T]

Context type

HonoContext::as_any

source

fn[T] HonoContext::as_any(self : HonoContext[T]) -> @mizchi/js_core.Any
Any

HonoCss

source

#external
pub type HonoCss

HonoCss::css

source

fn HonoCss::css(self : HonoCss, template : String, args? : Array[@mizchi/js_core.Any
Any]) -> CssClass

Create a CSS class using tagged template syntax.

Template format uses ${@0}, ${@1}, etc. as placeholders for interpolation. Returns a CssClass that can be used with jsx class attribute.

Example

// Simple usage without interpolation
let cls = hono_css.css("color: red")

// With interpolation

let color = "blue"

let size = 16

let cls = hono_css.css("color: ${@0}; font-size: ${@1}px", args=[
  @core.any(color),
  @core.any(size),
])

HonoCss::cx

source

fn HonoCss::cx(self : HonoCss, classes : Array[CssClass]) -> CssClass

Combine multiple CSS classes

HonoCss::keyframes

source

fn HonoCss::keyframes(self : HonoCss, template : String, args? : Array[@mizchi/js_core.Any
Any]) -> CssClass

Create keyframes animation using tagged template syntax.

Template format uses ${@0}, ${@1}, etc. as placeholders for interpolation. Returns a CssClass for the animation.

Example

// Simple usage
let anim = hono_css.keyframes("from { opacity: 0 } to { opacity: 1 }")

// With interpolation

let start = 0.5

let end = 1.0

let anim = hono_css.keyframes(
  "from { transform: scale(${@0}) } to { transform: scale(${@1}) }",
  args=[@core.any(start), @core.any(end)],
)

HonoCss::style_component

source

fn HonoCss::style_component(self : HonoCss, nonce? : String) -> JSXNode

Style component - renders collected CSS in head Must be included in the document head for CSS to work

HonoJsx

source

#external
pub type HonoJsx

HonoJsx::context_provider

source

fn[T] HonoJsx::context_provider(self : HonoJsx, ctx : HonoContext[T], children : Array[&HonoNode], value~ : T) -> JSXNode

Context Provider

HonoJsx::create_context

source

fn[T] HonoJsx::create_context(self : HonoJsx, defaultValue : T?) -> HonoContext[T]

Create a context

HonoJsx::fragment

source

fn HonoJsx::fragment(self : HonoJsx, children : Array[&HonoNode], key? : String) -> JSXNode

Fragment - groups elements without extra DOM nodes

HonoJsx::h

source

fn HonoJsx::h(self : HonoJsx, tag : String, children : Array[&HonoNode], props? : Map[String, @mizchi/js_core.Any
Any], style? : Map[String, String], class? : &CssClassName, id? : String, key? : String) -> JSXNode

Alias for jsx

HonoJsx::html

source

fn HonoJsx::html(self : HonoJsx, template : String) -> HtmlEscapedString

Create HTML from template string (escaped)

HonoJsx::jsx

source

fn HonoJsx::jsx(self : HonoJsx, tag : String, children : Array[&HonoNode], props? : Map[String, @mizchi/js_core.Any
Any], style? : Map[String, String], class? : &CssClassName, id? : String, key? : String) -> JSXNode

Create a JSX element using HonoJsx instance

HonoJsx::jsx_component

source

fn[T] HonoJsx::jsx_component(self : HonoJsx, tag : (T) -> JSXNode, props : T, children? : Array[&HonoNode], key? : String) -> JSXNode

Create element with component function

HonoJsx::memo

source

fn[T] HonoJsx::memo(self : HonoJsx, component : (T) -> JSXNode) -> ((T) -> JSXNode)

Memo - memoize a component

HonoJsx::raw

source

fn HonoJsx::raw(self : HonoJsx, html : String) -> JSXNode

Raw HTML - insert unescaped HTML

HonoJsx::render_to_readable_stream

source

fn HonoJsx::render_to_readable_stream(self : HonoJsx, node : JSXNode) -> @mizchi/js_core.Any
Any

Render JSX to ReadableStream (streaming)

HonoJsx::use_context

source

fn[T] HonoJsx::use_context(self : HonoJsx, ctx : HonoContext[T]) -> T

Use context value

HonoRequest

source

pub(all) struct HonoRequest {
  url : String
  bodyUsed : Bool
}

HonoRequest type - wrapper around Request

HonoRequest::arrayBuffer

source

#alias(array_buffer)
async fn HonoRequest::arrayBuffer(self : HonoRequest) -> @mizchi/js_core.Any
Any

Parse request body as array buffer https://hono.dev/docs/api/request#arraybuffer

HonoRequest::as_any

source

fn HonoRequest::as_any(self : HonoRequest) -> @mizchi/js_core.Any
Any

HonoRequest::blob

source

async fn HonoRequest::blob(self : HonoRequest) -> @mizchi/js_core.Any
Any

Parse request body as blob https://hono.dev/docs/api/request#blob

HonoRequest::formData

source

#alias(form_data)
async fn HonoRequest::formData(self : HonoRequest) -> @mizchi/js_web/http.FormData
FormData

Parse request body as form data https://hono.dev/docs/api/request#formdata

HonoRequest::header

source

fn HonoRequest::header(self : HonoRequest, key : String) -> String?

Get header value https://hono.dev/docs/api/request#header

HonoRequest::json

source

async fn HonoRequest::json(self : HonoRequest) -> @mizchi/js_core.Any
Any

Parse request body as JSON https://hono.dev/docs/api/request#json

HonoRequest::method_

source

fn HonoRequest::method_(self : HonoRequest) -> String

Get request method

HonoRequest::param

source

fn HonoRequest::param(self : HonoRequest, key : String) -> String?

Get path parameter https://hono.dev/docs/api/request#param

HonoRequest::paramAll

source

#alias(param_all)
fn HonoRequest::paramAll(self : HonoRequest) -> @mizchi/js_core.Any
Any

Get all path parameters

HonoRequest::parseBody

source

#alias(parse_body)
async fn HonoRequest::parseBody(self : HonoRequest, options? : @mizchi/js_core.Any
Any) -> @mizchi/js_core.Any
Any

Parse request body of multipart/form-data or application/x-www-form-urlencoded https://hono.dev/docs/api/request#parsebody

HonoRequest::path

source

fn HonoRequest::path(self : HonoRequest) -> String

Get request path

HonoRequest::query

source

fn HonoRequest::query(self : HonoRequest, key : String) -> String?

Get query parameter https://hono.dev/docs/api/request#query

HonoRequest::queryAll

source

#alias(query_all)
fn HonoRequest::queryAll(self : HonoRequest) -> @mizchi/js_core.Any
Any

Get all query parameters

HonoRequest::text

source

async fn HonoRequest::text(self : HonoRequest) -> String

Parse request body as text https://hono.dev/docs/api/request#text

HtmlEscapedString

source

#external
pub type HtmlEscapedString

HTML tagged template helper result

impl HonoNode for HtmlEscapedString

HtmlEscapedString::as_any

source

fn HtmlEscapedString::as_any(self : HtmlEscapedString) -> @mizchi/js_core.Any
Any

JSXNode

source

#external
pub type JSXNode

JSX Node type

impl HonoNode for JSXNode

JSXNode::as_any

source

fn JSXNode::as_any(self : JSXNode) -> @mizchi/js_core.Any
Any

JwtAlgorithm

source

pub(all) enum JwtAlgorithm {
  HS256
  HS384
  HS512
  RS256
  RS384
  RS512
  PS256
  PS384
  PS512
  ES256
  ES384
  ES512
  EdDSA
}

JWT Algorithm types

JwtDecoded

source

pub struct JwtDecoded {
  header : @mizchi/js_core.Any
Any
  payload : @mizchi/js_core.Any
Any
}

Decoded JWT result

JwtPayload

source

pub(all) struct JwtPayload {
  sub : String?
  iss : String?
  aud : String?
  exp : Int?
  nbf : Int?
  iat : Int?
  jti : String?
}

JWT Payload type

JwtPayload::default

source

fn JwtPayload::default() -> JwtPayload

Default JWT payload

context_provider

source

fn[T] context_provider(ctx : HonoContext[T], children : Array[&HonoNode], value~ : T) -> JSXNode

Context Provider (legacy - prefer HonoJsx::context_provider)

cors

source

fn cors(origin? : String, allowMethods? : Array[String], allowHeaders? : Array[String], maxAge? : Int, credentials? : Bool, exposeHeaders? : Array[String]) -> CorsMiddleware

Create CORS middleware https://hono.dev/docs/middleware/builtin/cors

create_context

source

fn[T] create_context(defaultValue : T?) -> HonoContext[T]

delete_cookie

source

fn[Env, ExecutionContext] delete_cookie(c : Context[Env, ExecutionContext], name : String, path? : String, secure? : Bool, domain? : String) -> String?

Delete a cookie https://hono.dev/docs/helpers/cookie#deletecookie

fragment

source

fn fragment(children : Array[&HonoNode], key? : String) -> JSXNode

Fragment (legacy - prefer HonoJsx::fragment) Note: Requires init_jsx_runtime() to be called first

get_all_cookies

source

fn[Env, ExecutionContext] get_all_cookies(c : Context[Env, ExecutionContext]) -> Map[String, String]

Get all cookies as a Map

get_cookie

source

fn[Env, ExecutionContext] get_cookie(c : Context[Env, ExecutionContext], name : String, prefix? : String) -> String?

Get a cookie value by name https://hono.dev/docs/helpers/cookie#getcookie

get_signed_cookie

source

async fn[Env, ExecutionContext] get_signed_cookie(c : Context[Env, ExecutionContext], secret : String, name : String) -> String?

Get a signed cookie (async) https://hono.dev/docs/helpers/cookie#getsignedcookie

hc

source

fn hc(base_url : String) -> HonoClient

Create a Hono RPC client https://hono.dev/docs/guides/rpc

html

source

fn html(template : String) -> HtmlEscapedString

import_hono_css

source

async fn import_hono_css() -> HonoCss

Import hono/css module

import_hono_jsx

source

async fn import_hono_jsx() -> HonoJsx

Import hono/jsx/jsx-runtime module

init_jsx_runtime

source

async fn init_jsx_runtime() -> Unit

Initialize the JSX runtime (must be called before using legacy jsx/fragment) This must be called before using the legacy fragment function in ESM environments.

jsx

source

#alias(h)
fn jsx(tag : String, children : Array[&HonoNode], props? : Map[String, @mizchi/js_core.Any
Any], style? : Map[String, String], class? : &CssClassName, id? : String, key? : String) -> JSXNode

Create a JSX element (legacy - prefer HonoJsx::jsx) class parameter accepts String or CssClass via CssClassName trait

jsx_component

source

fn[T] jsx_component(tag : (T) -> JSXNode, props : T, children? : Array[&HonoNode], key? : String) -> JSXNode

Create element with component function (legacy)

jwt_decode

source

fn jwt_decode(token : String) -> JwtDecoded

Decode a JWT token without verification https://hono.dev/docs/helpers/jwt#decode

jwt_sign

source

async fn jwt_sign(payload : @mizchi/js_core.Any
Any, secret : String, alg? : JwtAlgorithm) -> String

Sign a JWT token https://hono.dev/docs/helpers/jwt#sign

jwt_sign_payload

source

async fn jwt_sign_payload(payload : JwtPayload, secret : String, alg? : JwtAlgorithm) -> String

Sign a JWT token with structured payload

jwt_verify

source

async fn jwt_verify(token : String, secret : String, alg? : JwtAlgorithm) -> @mizchi/js_core.Any
Any

Verify a JWT token Returns the payload if valid, throws on invalid token https://hono.dev/docs/helpers/jwt#verify

memo

source

fn[T] memo(component : (T) -> JSXNode) -> ((T) -> JSXNode)

mount_auth

source

fn[Env, ExecutionContext] mount_auth(app : Hono[Env, ExecutionContext], auth : @mizchi/npm_typed/better_auth.Auth
Auth) -> Hono[Env, ExecutionContext]

Mount auth routes on Hono app at /api/auth/*

raw

source

fn raw(html : String) -> JSXNode

render_to_readable_stream

source

fn render_to_readable_stream(node : JSXNode) -> @mizchi/js_core.Any
Any

render_to_string

source

fn render_to_string(node : JSXNode) -> String

Render JSX to string

set_cookie

source

fn[Env, ExecutionContext] set_cookie(c : Context[Env, ExecutionContext], name : String, value : String, domain? : String, expires? : @mizchi/js_core.Any
Any, httpOnly? : Bool, maxAge? : Int, path? : String, secure? : Bool, sameSite? : String, priority? : String, prefix? : String, partitioned? : Bool) -> Unit

Set a cookie https://hono.dev/docs/helpers/cookie#setcookie

set_signed_cookie

source

async fn[Env, ExecutionContext] set_signed_cookie(c : Context[Env, ExecutionContext], name : String, value : String, secret : String, domain? : String, expires? : @mizchi/js_core.Any
Any, httpOnly? : Bool, maxAge? : Int, path? : String, secure? : Bool, sameSite? : String, priority? : String, prefix? : String, partitioned? : Bool) -> Unit

Set a signed cookie (async) https://hono.dev/docs/helpers/cookie#setsignedcookie

test_client

source

fn[Env, ExecutionContext] test_client(app : Hono[Env, ExecutionContext]) -> HonoClient

Create a test client for a Hono application Original: testClient(app)

toHonoHandler

source

fn[Env, ExecutionContext] toHonoHandler(auth : @mizchi/npm_typed/better_auth.Auth
Auth) -> (async (Context[Env, ExecutionContext]) -> @mizchi/js_web/http.Response
Response)

Convert auth handler to Hono handler

use_context

source

fn[T] use_context(ctx : HonoContext[T]) -> T

Source Files

Site source Report issue Packages Build queue Skills Statistics

#mizchi/npm_typed/hono

#Installation

#Features

#Usage

#Basic Example

#JSX with HonoJsx (Recommended)

#JSX with Legacy API

#ESM Migration Notes

#Why init_jsx_runtime() is needed

#Recommendation

#Example

#FC

#Handler

#Middleware

#CssClassName

#HonoNode

#ClientEndpoint

#ClientEndpoint::as_any

#ClientEndpoint::delete_

#ClientEndpoint::get_

#ClientEndpoint::patch_

#ClientEndpoint::post_

#ClientEndpoint::put_

#ClientEndpoint::url_

#ClientResponse

#ClientResponse::arrayBuffer

#ClientResponse::as_any

#ClientResponse::blob

#ClientResponse::headers

#ClientResponse::json

#ClientResponse::ok

#ClientResponse::status

#ClientResponse::text

#Context

#Context::as_any

#Context::body

#Context::executionCtx

#Context::getValue

#Context::header

#Context::html

#Context::html_jsx

#Context::json

#Context::notFound

#Context::redirect

#Context::render

#Context::res

#Context::set

#Context::setRenderer

#Context::status

#Context::stream_jsx

#Context::text

#Context::var_

#CorsMiddleware

#CorsMiddleware::as_any

#CssClass

#CssClass::as_any

#CssClass::to_string

#Hono

#Hono::all

#Hono::as_any

#Hono::basePath

#Hono::cors

#Hono::cors_all

#Hono::delete

#Hono::fetch

#Hono::fire

#Hono::get

#Hono::mount

#Hono::new

#Hono::notFound

#Hono::onError

#Hono::options

#Hono::patch

#Hono::post

#Hono::put

#Hono::route

#Hono::use_

#Hono::useall

#HonoClient

#HonoClient::as_any

FC

Handler

Middleware

CssClassName

HonoNode

ClientEndpoint

ClientEndpoint::as_any

ClientEndpoint::delete_

ClientEndpoint::get_

ClientEndpoint::patch_

ClientEndpoint::post_

ClientEndpoint::put_

ClientEndpoint::url_

ClientResponse

ClientResponse::arrayBuffer

ClientResponse::as_any

ClientResponse::blob

ClientResponse::headers

ClientResponse::json

ClientResponse::ok

ClientResponse::status

ClientResponse::text

Context

Context::as_any

Context::body

Context::executionCtx

Context::getValue

Context::header

Context::html

Context::html_jsx

Context::json

Context::notFound

Context::redirect

Context::render

Context::res

Context::set

Context::setRenderer

Context::status

Context::stream_jsx

Context::text

Context::var_

CorsMiddleware

CorsMiddleware::as_any

CssClass

CssClass::as_any

CssClass::to_string

Hono

Hono::all

Hono::as_any

Hono::basePath

Hono::cors

Hono::cors_all

Hono::delete

Hono::fetch

Hono::fire

Hono::get

Hono::mount

Hono::new

Hono::notFound

Hono::onError

Hono::options

Hono::patch

Hono::post

Hono::put

Hono::route

Hono::use_

Hono::useall

HonoClient

HonoClient::as_any

HonoClient::path

HonoContext

HonoContext::as_any

HonoCss

HonoCss::css

HonoCss::cx

HonoCss::keyframes

HonoCss::style_component

HonoJsx

HonoJsx::context_provider

HonoJsx::create_context