@kerebron/extension-server-hono 0.4.28 → 0.4.30

package/src/deps/jsr.io/@hono/hono/4.11.3/src/helper/websocket/index.ts

@@ -0,0 +1,140 @@
+/**
+ * @module
+ * WebSocket Helper for Hono.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { Context } from '../../context.js'
+import type { MiddlewareHandler, TypedResponse } from '../../types.js'
+import type { StatusCode } from '../../utils/http-status.js'
+
+/**
+ * WebSocket Event Listeners type
+ */
+export interface WSEvents<T = unknown> {
+  onOpen?: (evt: Event, ws: WSContext<T>) => void
+  onMessage?: (evt: MessageEvent<WSMessageReceive>, ws: WSContext<T>) => void
+  onClose?: (evt: CloseEvent, ws: WSContext<T>) => void
+  onError?: (evt: Event, ws: WSContext<T>) => void
+}
+
+/**
+ * Upgrade WebSocket Type
+ */
+export interface UpgradeWebSocket<T = unknown, U = any, _WSEvents = WSEvents<T>> {
+  (
+    createEvents: (c: Context) => _WSEvents | Promise<_WSEvents>,
+    options?: U
+  ): MiddlewareHandler<
+    any,
+    string,
+    {
+      outputFormat: 'ws'
+    }
+  >
+  (
+    c: Context,
+    events: _WSEvents,
+    options?: U
+  ): Promise<Response & TypedResponse<{}, StatusCode, 'ws'>>
+}
+
+/**
+ * ReadyState for WebSocket
+ */
+export type WSReadyState = 0 | 1 | 2 | 3
+
+/**
+ * An argument for WSContext class
+ */
+export interface WSContextInit<T = unknown> {
+  send(data: string | ArrayBuffer | Uint8Array, options: SendOptions): void
+  close(code?: number, reason?: string): void
+
+  raw?: T
+  readyState: WSReadyState
+  url?: string | URL | null
+  protocol?: string | null
+}
+
+/**
+ * Options for sending message
+ */
+export interface SendOptions {
+  compress?: boolean
+}
+
+/**
+ * A context for controlling WebSockets
+ */
+export class WSContext<T = unknown> {
+  #init: WSContextInit<T>
+  constructor(init: WSContextInit<T>) {
+    this.#init = init
+    this.raw = init.raw
+    this.url = init.url ? new URL(init.url) : null
+    this.protocol = init.protocol ?? null
+  }
+  send(source: string | ArrayBuffer | Uint8Array<ArrayBuffer>, options?: SendOptions): void {
+    this.#init.send(source, options ?? {})
+  }
+  raw?: T
+  binaryType: BinaryType = 'arraybuffer'
+  get readyState(): WSReadyState {
+    return this.#init.readyState
+  }
+  url: URL | null
+  protocol: string | null
+  close(code?: number, reason?: string) {
+    this.#init.close(code, reason)
+  }
+}
+
+export type WSMessageReceive = string | Blob | ArrayBufferLike
+
+export const createWSMessageEvent = (source: WSMessageReceive): MessageEvent<WSMessageReceive> => {
+  return new MessageEvent<WSMessageReceive>('message', {
+    data: source,
+  })
+}
+
+export interface WebSocketHelperDefineContext {}
+export type WebSocketHelperDefineHandler<T, U> = (
+  c: Context,
+  events: WSEvents<T>,
+  options?: U
+) => Promise<Response | void> | Response | void
+
+/**
+ * Create a WebSocket adapter/helper
+ */
+export const defineWebSocketHelper = <T = unknown, U = any>(
+  handler: WebSocketHelperDefineHandler<T, U>
+): UpgradeWebSocket<T, U> => {
+  return ((
+    ...args:
+      | [createEvents: (c: Context) => WSEvents<T> | Promise<WSEvents<T>>, options?: U]
+      | [c: Context, events: WSEvents<T>, options?: U]
+  ) => {
+    if (typeof args[0] === 'function') {
+      const [createEvents, options] = args
+      return async function upgradeWebSocket(c, next) {
+        const events = await createEvents(c)
+        const result = await handler(c, events, options as U)
+        if (result) {
+          return result
+        }
+        await next()
+      }
+    } else {
+      const [c, events, options] = args as [c: Context, events: WSEvents<T>, options?: U]
+      return (async () => {
+        const upgraded = await handler(c, events, options as U)
+        if (!upgraded) {
+          throw new Error('Failed to upgrade WebSocket')
+        }
+        return upgraded
+      })()
+    }
+  }) as UpgradeWebSocket<T, U>
+}

package/src/deps/jsr.io/@hono/hono/4.11.3/src/hono-base.ts

@@ -0,0 +1,539 @@
+/**
+ * @module
+ * This module is the base module for the Hono object.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { compose } from './compose.js'
+import { Context } from './context.js'
+import type { ExecutionContext } from './context.js'
+import type { Router } from './router.js'
+import { METHODS, METHOD_NAME_ALL, METHOD_NAME_ALL_LOWERCASE } from './router.js'
+import type {
+  Env,
+  ErrorHandler,
+  FetchEventLike,
+  H,
+  HandlerInterface,
+  MergePath,
+  MergeSchemaPath,
+  MiddlewareHandler,
+  MiddlewareHandlerInterface,
+  Next,
+  NotFoundHandler,
+  OnHandlerInterface,
+  RouterRoute,
+  Schema,
+} from './types.js'
+import { COMPOSED_HANDLER } from './utils/constants.js'
+import { getPath, getPathNoStrict, mergePath } from './utils/url.js'
+
+const notFoundHandler: NotFoundHandler = (c) => {
+  return c.text('404 Not Found', 404)
+}
+
+const errorHandler: ErrorHandler = (err, c) => {
+  if ('getResponse' in err) {
+    const res = err.getResponse()
+    return c.newResponse(res.body, res)
+  }
+  console.error(err)
+  return c.text('Internal Server Error', 500)
+}
+
+type GetPath<E extends Env> = (request: Request, options?: { env?: E['Bindings'] }) => string
+
+export type HonoOptions<E extends Env> = {
+  /**
+   * `strict` option specifies whether to distinguish whether the last path is a directory or not.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#strict-mode}
+   *
+   * @default true
+   */
+  strict?: boolean
+  /**
+   * `router` option specifies which router to use.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#router-option}
+   *
+   * @example
+   * ```ts
+   * const app = new Hono({ router: new RegExpRouter() })
+   * ```
+   */
+  router?: Router<[H, RouterRoute]>
+  /**
+   * `getPath` can handle the host header value.
+   *
+   * @see {@link https://hono.dev/docs/api/routing#routing-with-host-header-value}
+   *
+   * @example
+   * ```ts
+   * const app = new Hono({
+   *  getPath: (req) =>
+   *   '/' + req.headers.get('host') + req.url.replace(/^https?:\/\/[^/]+(\/[^?]*)/, '$1'),
+   * })
+   *
+   * app.get('/www1.example.com/hello', () => c.text('hello www1'))
+   *
+   * // A following request will match the route:
+   * // new Request('http://www1.example.com/hello', {
+   * //  headers: { host: 'www1.example.com' },
+   * // })
+   * ```
+   */
+  getPath?: GetPath<E>
+}
+
+type MountOptionHandler = (c: Context) => unknown
+type MountReplaceRequest = (originalRequest: Request) => Request
+type MountOptions =
+  | MountOptionHandler
+  | {
+      optionHandler?: MountOptionHandler
+      replaceRequest?: MountReplaceRequest | false
+    }
+
+class Hono<
+  E extends Env = Env,
+  S extends Schema = {},
+  BasePath extends string = '/',
+  CurrentPath extends string = BasePath,
+> {
+  get!: HandlerInterface<E, 'get', S, BasePath, CurrentPath>
+  post!: HandlerInterface<E, 'post', S, BasePath, CurrentPath>
+  put!: HandlerInterface<E, 'put', S, BasePath, CurrentPath>
+  delete!: HandlerInterface<E, 'delete', S, BasePath, CurrentPath>
+  options!: HandlerInterface<E, 'options', S, BasePath, CurrentPath>
+  patch!: HandlerInterface<E, 'patch', S, BasePath, CurrentPath>
+  all!: HandlerInterface<E, 'all', S, BasePath, CurrentPath>
+  on: OnHandlerInterface<E, S, BasePath>
+  use: MiddlewareHandlerInterface<E, S, BasePath>
+
+  /*
+    This class is like an abstract class and does not have a router.
+    To use it, inherit the class and implement router in the constructor.
+  */
+  router!: Router<[H, RouterRoute]>
+  readonly getPath: GetPath<E>
+  // Cannot use `#` because it requires visibility at JavaScript runtime.
+  private _basePath: string = '/'
+  #path: string = '/'
+
+  routes: RouterRoute[] = []
+
+  constructor(options: HonoOptions<E> = {}) {
+    // Implementation of app.get(...handlers[]) or app.get(path, ...handlers[])
+    const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE]
+    allMethods.forEach((method) => {
+      this[method] = (args1: string | H, ...args: H[]) => {
+        if (typeof args1 === 'string') {
+          this.#path = args1
+        } else {
+          this.#addRoute(method, this.#path, args1)
+        }
+        args.forEach((handler) => {
+          this.#addRoute(method, this.#path, handler)
+        })
+        return this as any
+      }
+    })
+
+    // Implementation of app.on(method, path, ...handlers[])
+    this.on = (method: string | string[], path: string | string[], ...handlers: H[]) => {
+      for (const p of [path].flat()) {
+        this.#path = p
+        for (const m of [method].flat()) {
+          handlers.map((handler) => {
+            this.#addRoute(m.toUpperCase(), this.#path, handler)
+          })
+        }
+      }
+      return this as any
+    }
+
+    // Implementation of app.use(...handlers[]) or app.use(path, ...handlers[])
+    this.use = (arg1: string | MiddlewareHandler<any>, ...handlers: MiddlewareHandler<any>[]) => {
+      if (typeof arg1 === 'string') {
+        this.#path = arg1
+      } else {
+        this.#path = '*'
+        handlers.unshift(arg1)
+      }
+      handlers.forEach((handler) => {
+        this.#addRoute(METHOD_NAME_ALL, this.#path, handler)
+      })
+      return this as any
+    }
+
+    const { strict, ...optionsWithoutStrict } = options
+    Object.assign(this, optionsWithoutStrict)
+    this.getPath = (strict ?? true) ? (options.getPath ?? getPath) : getPathNoStrict
+  }
+
+  #clone(): Hono<E, S, BasePath, CurrentPath> {
+    const clone = new Hono<E, S, BasePath, CurrentPath>({
+      router: this.router,
+      getPath: this.getPath,
+    })
+    clone.errorHandler = this.errorHandler
+    clone.#notFoundHandler = this.#notFoundHandler
+    clone.routes = this.routes
+    return clone
+  }
+
+  #notFoundHandler: NotFoundHandler = notFoundHandler
+  // Cannot use `#` because it requires visibility at JavaScript runtime.
+  private errorHandler: ErrorHandler = errorHandler
+
+  /**
+   * `.route()` allows grouping other Hono instance in routes.
+   *
+   * @see {@link https://hono.dev/docs/api/routing#grouping}
+   *
+   * @param {string} path - base Path
+   * @param {Hono} app - other Hono instance
+   * @returns {Hono} routed Hono instance
+   *
+   * @example
+   * ```ts
+   * const app = new Hono()
+   * const app2 = new Hono()
+   *
+   * app2.get("/user", (c) => c.text("user"))
+   * app.route("/api", app2) // GET /api/user
+   * ```
+   */
+  route<
+    SubPath extends string,
+    SubEnv extends Env,
+    SubSchema extends Schema,
+    SubBasePath extends string,
+    SubCurrentPath extends string,
+  >(
+    path: SubPath,
+    app: Hono<SubEnv, SubSchema, SubBasePath, SubCurrentPath>
+  ): Hono<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> | S, BasePath, CurrentPath> {
+    const subApp = this.basePath(path)
+    app.routes.map((r) => {
+      let handler
+      if (app.errorHandler === errorHandler) {
+        handler = r.handler
+      } else {
+        handler = async (c: Context, next: Next) =>
+          (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res
+        ;(handler as any)[COMPOSED_HANDLER] = r.handler
+      }
+
+      subApp.#addRoute(r.method, r.path, handler)
+    })
+    return this
+  }
+
+  /**
+   * `.basePath()` allows base paths to be specified.
+   *
+   * @see {@link https://hono.dev/docs/api/routing#base-path}
+   *
+   * @param {string} path - base Path
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * const api = new Hono().basePath('/api')
+   * ```
+   */
+  basePath<SubPath extends string>(
+    path: SubPath
+  ): Hono<E, S, MergePath<BasePath, SubPath>, MergePath<BasePath, SubPath>> {
+    const subApp = this.#clone()
+    subApp._basePath = mergePath(this._basePath, path)
+    return subApp
+  }
+
+  /**
+   * `.onError()` handles an error and returns a customized Response.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#error-handling}
+   *
+   * @param {ErrorHandler} handler - request Handler for error
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * app.onError((err, c) => {
+   *   console.error(`${err}`)
+   *   return c.text('Custom Error Message', 500)
+   * })
+   * ```
+   */
+  onError = (handler: ErrorHandler<E>): Hono<E, S, BasePath, CurrentPath> => {
+    this.errorHandler = handler
+    return this
+  }
+
+  /**
+   * `.notFound()` allows you to customize a Not Found Response.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#not-found}
+   *
+   * @param {NotFoundHandler} handler - request handler for not-found
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * app.notFound((c) => {
+   *   return c.text('Custom 404 Message', 404)
+   * })
+   * ```
+   */
+  notFound = (handler: NotFoundHandler<E>): Hono<E, S, BasePath, CurrentPath> => {
+    this.#notFoundHandler = handler
+    return this
+  }
+
+  /**
+   * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#mount}
+   *
+   * @param {string} path - base Path
+   * @param {Function} applicationHandler - other Request Handler
+   * @param {MountOptions} [options] - options of `.mount()`
+   * @returns {Hono} mounted Hono instance
+   *
+   * @example
+   * ```ts
+   * import { Router as IttyRouter } from 'itty-router'
+   * import { Hono } from 'hono'
+   * // Create itty-router application
+   * const ittyRouter = IttyRouter()
+   * // GET /itty-router/hello
+   * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+   *
+   * const app = new Hono()
+   * app.mount('/itty-router', ittyRouter.handle)
+   * ```
+   *
+   * @example
+   * ```ts
+   * const app = new Hono()
+   * // Send the request to another application without modification.
+   * app.mount('/app', anotherApp, {
+   *   replaceRequest: (req) => req,
+   * })
+   * ```
+   */
+  mount(
+    path: string,
+    applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>,
+    options?: MountOptions
+  ): Hono<E, S, BasePath, CurrentPath> {
+    // handle options
+    let replaceRequest: MountReplaceRequest | undefined
+    let optionHandler: MountOptionHandler | undefined
+    if (options) {
+      if (typeof options === 'function') {
+        optionHandler = options
+      } else {
+        optionHandler = options.optionHandler
+        if (options.replaceRequest === false) {
+          replaceRequest = (request) => request
+        } else {
+          replaceRequest = options.replaceRequest
+        }
+      }
+    }
+
+    // prepare handlers for request
+    const getOptions: (c: Context) => unknown[] = optionHandler
+      ? (c) => {
+          const options = optionHandler!(c)
+          return Array.isArray(options) ? options : [options]
+        }
+      : (c) => {
+          let executionContext: ExecutionContext | undefined = undefined
+          try {
+            executionContext = c.executionCtx
+          } catch {} // Do nothing
+          return [c.env, executionContext]
+        }
+    replaceRequest ||= (() => {
+      const mergedPath = mergePath(this._basePath, path)
+      const pathPrefixLength = mergedPath === '/' ? 0 : mergedPath.length
+      return (request) => {
+        const url = new URL(request.url)
+        url.pathname = url.pathname.slice(pathPrefixLength) || '/'
+        return new Request(url, request)
+      }
+    })()
+
+    const handler: MiddlewareHandler = async (c, next) => {
+      const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c))
+
+      if (res) {
+        return res
+      }
+
+      await next()
+    }
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path, '*'), handler)
+    return this
+  }
+
+  #addRoute(method: string, path: string, handler: H): void {
+    method = method.toUpperCase()
+    path = mergePath(this._basePath, path)
+    const r: RouterRoute = { basePath: this._basePath, path, method, handler }
+    this.router.add(method, path, [handler, r])
+    this.routes.push(r)
+  }
+
+  #handleError(err: unknown, c: Context<E>): Response | Promise<Response> {
+    if (err instanceof Error) {
+      return this.errorHandler(err, c)
+    }
+    throw err
+  }
+
+  #dispatch(
+    request: Request,
+    executionCtx: ExecutionContext | FetchEventLike | undefined,
+    env: E['Bindings'],
+    method: string
+  ): Response | Promise<Response> {
+    // Handle HEAD method
+    if (method === 'HEAD') {
+      return (async () =>
+        new Response(null, await this.#dispatch(request, executionCtx, env, 'GET')))()
+    }
+
+    const path = this.getPath(request, { env })
+    const matchResult = this.router.match(method, path)
+
+    const c = new Context(request, {
+      path,
+      matchResult,
+      env,
+      executionCtx,
+      notFoundHandler: this.#notFoundHandler,
+    })
+
+    // Do not `compose` if it has only one handler
+    if (matchResult[0].length === 1) {
+      let res: ReturnType<H>
+      try {
+        res = matchResult[0][0][0][0](c, async () => {
+          c.res = await this.#notFoundHandler(c)
+        })
+      } catch (err) {
+        return this.#handleError(err, c)
+      }
+
+      return res instanceof Promise
+        ? res
+            .then(
+              (resolved: Response | undefined) =>
+                resolved || (c.finalized ? c.res : this.#notFoundHandler(c))
+            )
+            .catch((err: Error) => this.#handleError(err, c))
+        : (res ?? this.#notFoundHandler(c))
+    }
+
+    const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler)
+
+    return (async () => {
+      try {
+        const context = await composed(c)
+        if (!context.finalized) {
+          throw new Error(
+            'Context is not finalized. Did you forget to return a Response object or `await next()`?'
+          )
+        }
+
+        return context.res
+      } catch (err) {
+        return this.#handleError(err, c)
+      }
+    })()
+  }
+
+  /**
+   * `.fetch()` will be entry point of your app.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#fetch}
+   *
+   * @param {Request} request - request Object of request
+   * @param {Env} Env - env Object
+   * @param {ExecutionContext} - context of execution
+   * @returns {Response | Promise<Response>} response of request
+   *
+   */
+  fetch: (
+    request: Request,
+    Env?: E['Bindings'] | {},
+    executionCtx?: ExecutionContext
+  ) => Response | Promise<Response> = (request, ...rest) => {
+    return this.#dispatch(request, rest[1], rest[0], request.method)
+  }
+
+  /**
+   * `.request()` is a useful method for testing.
+   * You can pass a URL or pathname to send a GET request.
+   * app will return a Response object.
+   * ```ts
+   * test('GET /hello is ok', async () => {
+   *   const res = await app.request('/hello')
+   *   expect(res.status).toBe(200)
+   * })
+   * ```
+   * @see https://hono.dev/docs/api/hono#request
+   */
+  request = (
+    input: RequestInfo | URL,
+    requestInit?: RequestInit,
+    Env?: E['Bindings'] | {},
+    executionCtx?: ExecutionContext
+  ): Response | Promise<Response> => {
+    if (input instanceof Request) {
+      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx)
+    }
+    input = input.toString()
+    return this.fetch(
+      new Request(
+        /^https?:\/\//.test(input) ? input : `http://localhost${mergePath('/', input)}`,
+        requestInit
+      ),
+      Env,
+      executionCtx
+    )
+  }
+
+  /**
+   * `.fire()` automatically adds a global fetch event listener.
+   * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
+   * @deprecated
+   * Use `fire` from `hono/service-worker` instead.
+   * ```ts
+   * import { Hono } from 'hono'
+   * import { fire } from 'hono/service-worker'
+   *
+   * const app = new Hono()
+   * // ...
+   * fire(app)
+   * ```
+   * @see https://hono.dev/docs/api/hono#fire
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+   * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
+   */
+  fire = (): void => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    addEventListener('fetch', (event: FetchEventLike): void => {
+      event.respondWith(this.#dispatch(event.request, event, undefined, event.request.method))
+    })
+  }
+}
+
+export { Hono as HonoBase }