bluera-knowledge 0.9.21

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/bun/serve-static.ts

@@ -0,0 +1,35 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { serveStatic as baseServeStatic } from '../../middleware/serve-static'
+import type { ServeStaticOptions } from '../../middleware/serve-static'
+import type { Env, MiddlewareHandler } from '../../types'
+import { stat } from 'node:fs/promises'
+
+export const serveStatic = <E extends Env = Env>(
+  options: ServeStaticOptions<E>
+): MiddlewareHandler => {
+  return async function serveStatic(c, next) {
+    const getContent = async (path: string) => {
+      path = `./${path}`
+      // @ts-ignore
+      const file = Bun.file(path)
+      return (await file.exists()) ? file : null
+    }
+    const pathResolve = (path: string) => {
+      return `./${path}`
+    }
+    const isDir = async (path: string) => {
+      let isDir
+      try {
+        const stats = await stat(path)
+        isDir = stats.isDirectory()
+      } catch {}
+      return isDir
+    }
+    return baseServeStatic({
+      ...options,
+      getContent,
+      pathResolve,
+      isDir,
+    })(c, next)
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/bun/server.ts

@@ -0,0 +1,30 @@
+/**
+ * Getting Bun Server Object for Bun adapters
+ * @module
+ */
+import type { Context } from '../../context'
+
+/**
+ * Bun Server Object
+ */
+export interface BunServer {
+  requestIP?: (req: Request) => {
+    address: string
+    family: string
+    port: number
+  }
+  upgrade<T>(
+    req: Request,
+    options?: {
+      data: T
+    }
+  ): boolean
+}
+
+/**
+ * Get Bun Server Object from Context
+ * @param c Context
+ * @returns Bun Server
+ */
+export const getBunServer = (c: Context): BunServer | undefined =>
+  ('server' in c.env ? c.env.server : c.env) as BunServer | undefined

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/bun/ssg.ts

@@ -0,0 +1,27 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { toSSG as baseToSSG } from '../../helper/ssg'
+import type { FileSystemModule, ToSSGAdaptorInterface } from '../../helper/ssg'
+
+// @ts-ignore
+const { write } = Bun
+
+/**
+ * @experimental
+ * `bunFileSystemModule` is an experimental feature.
+ * The API might be changed.
+ */
+export const bunFileSystemModule: FileSystemModule = {
+  writeFile: async (path, data) => {
+    await write(path, data)
+  },
+  mkdir: async () => {},
+}
+
+/**
+ * @experimental
+ * `toSSG` is an experimental feature.
+ * The API might be changed.
+ */
+export const toSSG: ToSSGAdaptorInterface = async (app, options) => {
+  return baseToSSG(app, bunFileSystemModule, options)
+}

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/bun/websocket.ts

@@ -0,0 +1,110 @@
+import { createWSMessageEvent } from '../../helper/websocket'
+import type {
+  UpgradeWebSocket,
+  WSContext,
+  WSEvents,
+  WSMessageReceive,
+} from '../../helper/websocket'
+import { getBunServer } from './server'
+
+interface BunServerWebSocket<T> {
+  send(data: string | ArrayBufferLike, compress?: boolean): void
+  close(code?: number, reason?: string): void
+  data: T
+  readyState: 0 | 1 | 2 | 3
+}
+
+interface BunWebSocketHandler<T> {
+  open(ws: BunServerWebSocket<T>): void
+  close(ws: BunServerWebSocket<T>, code?: number, reason?: string): void
+  message(ws: BunServerWebSocket<T>, message: string | Uint8Array): void
+}
+interface CreateWebSocket<T> {
+  upgradeWebSocket: UpgradeWebSocket<T>
+  websocket: BunWebSocketHandler<BunWebSocketData>
+}
+export interface BunWebSocketData {
+  connId: number
+  url: URL
+  protocol: string
+}
+
+const createWSContext = (ws: BunServerWebSocket<BunWebSocketData>): WSContext => {
+  return {
+    send: (source, options) => {
+      const sendingData =
+        typeof source === 'string' ? source : source instanceof Uint8Array ? source.buffer : source
+      ws.send(sendingData, options?.compress)
+    },
+    raw: ws,
+    binaryType: 'arraybuffer',
+    readyState: ws.readyState,
+    url: ws.data.url,
+    protocol: ws.data.protocol,
+    close(code, reason) {
+      ws.close(code, reason)
+    },
+  }
+}
+
+export const createBunWebSocket = <T>(): CreateWebSocket<T> => {
+  const websocketConns: WSEvents[] = []
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const upgradeWebSocket: UpgradeWebSocket<any> = (createEvents) => {
+    return async (c, next) => {
+      const server = getBunServer(c)
+      if (!server) {
+        throw new TypeError('env has to include the 2nd argument of fetch.')
+      }
+      const connId = websocketConns.push(await createEvents(c)) - 1
+      const upgradeResult = server.upgrade<BunWebSocketData>(c.req.raw, {
+        data: {
+          connId,
+          url: new URL(c.req.url),
+          protocol: c.req.url,
+        },
+      })
+      if (upgradeResult) {
+        return new Response(null)
+      }
+      await next() // Failed
+    }
+  }
+  const websocket: BunWebSocketHandler<BunWebSocketData> = {
+    open(ws) {
+      const websocketListeners = websocketConns[ws.data.connId]
+      if (websocketListeners.onOpen) {
+        websocketListeners.onOpen(new Event('open'), createWSContext(ws))
+      }
+    },
+    close(ws, code, reason) {
+      const websocketListeners = websocketConns[ws.data.connId]
+      if (websocketListeners.onClose) {
+        websocketListeners.onClose(
+          new CloseEvent('close', {
+            code,
+            reason,
+          }),
+          createWSContext(ws)
+        )
+      }
+    },
+    message(ws, message) {
+      const websocketListeners = websocketConns[ws.data.connId]
+      if (websocketListeners.onMessage) {
+        const normalizedReceiveData =
+          typeof message === 'string' ? message : (message.buffer satisfies WSMessageReceive)
+
+        websocketListeners.onMessage(
+          createWSMessageEvent(normalizedReceiveData),
+          createWSContext(ws)
+        )
+      }
+    },
+  }
+  return {
+    upgradeWebSocket,
+    websocket,
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/cloudflare-pages/handler.ts

@@ -0,0 +1,120 @@
+import { Context } from '../../context'
+import type { Hono } from '../../hono'
+import { HTTPException } from '../../http-exception'
+import type { BlankSchema, Env, Input, MiddlewareHandler, Schema } from '../../types'
+
+// Ref: https://github.com/cloudflare/workerd/blob/main/types/defines/pages.d.ts
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Params<P extends string = any> = Record<P, string | string[]>
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type EventContext<Env = {}, P extends string = any, Data = Record<string, unknown>> = {
+  request: Request
+  functionPath: string
+  waitUntil: (promise: Promise<unknown>) => void
+  passThroughOnException: () => void
+  next: (input?: Request | string, init?: RequestInit) => Promise<Response>
+  env: Env & { ASSETS: { fetch: typeof fetch } }
+  params: Params<P>
+  data: Data
+}
+
+declare type PagesFunction<
+  Env = unknown,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Params extends string = any,
+  Data extends Record<string, unknown> = Record<string, unknown>
+> = (context: EventContext<Env, Params, Data>) => Response | Promise<Response>
+
+export const handle =
+  <E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'>(
+    app: Hono<E, S, BasePath>
+  ): PagesFunction<E['Bindings']> =>
+  (eventContext) => {
+    return app.fetch(
+      eventContext.request,
+      { ...eventContext.env, eventContext },
+      {
+        waitUntil: eventContext.waitUntil,
+        passThroughOnException: eventContext.passThroughOnException,
+      }
+    )
+  }
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function handleMiddleware<E extends Env = {}, P extends string = any, I extends Input = {}>(
+  middleware: MiddlewareHandler<
+    E & {
+      Bindings: {
+        eventContext: EventContext
+      }
+    },
+    P,
+    I
+  >
+): PagesFunction<E['Bindings']> {
+  return async (executionCtx) => {
+    const context = new Context(executionCtx.request, {
+      env: { ...executionCtx.env, eventContext: executionCtx },
+      executionCtx,
+    })
+
+    let response: Response | void = undefined
+
+    try {
+      response = await middleware(context, async () => {
+        try {
+          context.res = await executionCtx.next()
+        } catch (error) {
+          if (error instanceof Error) {
+            context.error = error
+          } else {
+            throw error
+          }
+        }
+      })
+    } catch (error) {
+      if (error instanceof Error) {
+        context.error = error
+      } else {
+        throw error
+      }
+    }
+
+    if (response) {
+      return response
+    }
+
+    if (context.error instanceof HTTPException) {
+      return context.error.getResponse()
+    }
+
+    if (context.error) {
+      throw context.error
+    }
+
+    return context.res
+  }
+}
+
+declare abstract class FetcherLike {
+  fetch(input: RequestInfo, init?: RequestInit): Promise<Response>
+}
+
+/**
+ *
+ * @description `serveStatic()` is for advanced mode:
+ * https://developers.cloudflare.com/pages/platform/functions/advanced-mode/#set-up-a-function
+ *
+ */
+export const serveStatic = (): MiddlewareHandler => {
+  return async (c) => {
+    const env = c.env as { ASSETS: FetcherLike }
+    const res = await env.ASSETS.fetch(c.req.raw)
+    if (res.status === 404) {
+      return c.notFound()
+    }
+    return res
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/cloudflare-pages/index.ts

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * Cloudflare Pages Adapter for Hono.
+ */
+
+export { handle, handleMiddleware, serveStatic } from './handler'
+export type { EventContext } from './handler'

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/cloudflare-workers/conninfo.ts

@@ -0,0 +1,7 @@
+import type { GetConnInfo } from '../../helper/conninfo'
+
+export const getConnInfo: GetConnInfo = (c) => ({
+  remote: {
+    address: c.req.header('cf-connecting-ip'),
+  },
+})

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/cloudflare-workers/index.ts

@@ -0,0 +1,8 @@
+/**
+ * @module
+ * Cloudflare Workers Adapter for Hono.
+ */
+
+export { serveStatic } from './serve-static-module'
+export { upgradeWebSocket } from './websocket'
+export { getConnInfo } from './conninfo'

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/cloudflare-workers/serve-static-module.ts

@@ -0,0 +1,12 @@
+// For ES module mode
+import type { Env, MiddlewareHandler } from '../../types'
+import type { ServeStaticOptions } from './serve-static'
+import { serveStatic } from './serve-static'
+
+const module = <E extends Env = Env>(
+  options: Omit<ServeStaticOptions<E>, 'namespace'>
+): MiddlewareHandler => {
+  return serveStatic<E>(options)
+}
+
+export { module as serveStatic }

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/cloudflare-workers/serve-static.ts

@@ -0,0 +1,39 @@
+import { serveStatic as baseServeStatic } from '../../middleware/serve-static'
+import type { ServeStaticOptions as BaseServeStaticOptions } from '../../middleware/serve-static'
+import type { Env, MiddlewareHandler } from '../../types'
+import { getContentFromKVAsset } from './utils'
+
+export type ServeStaticOptions<E extends Env = Env> = BaseServeStaticOptions<E> & {
+  // namespace is KVNamespace
+  namespace?: unknown
+  manifest: object | string
+}
+
+/**
+ * @deprecated
+ * `serveStatic` in the Cloudflare Workers adapter is deprecated.
+ * If you want to create an application serving static assets, please consider using Cloudflare Pages.
+ * You can start to create the Cloudflare Pages application with the `npm create hono@latest` command.
+ */
+export const serveStatic = <E extends Env = Env>(
+  options: ServeStaticOptions<E>
+): MiddlewareHandler => {
+  return async function serveStatic(c, next) {
+    const getContent = async (path: string) => {
+      return getContentFromKVAsset(path, {
+        manifest: options.manifest,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        namespace: options.namespace
+          ? options.namespace
+          : c.env
+          ? c.env.__STATIC_CONTENT
+          : undefined,
+      })
+    }
+    return baseServeStatic({
+      ...options,
+      getContent,
+    })(c, next)
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/cloudflare-workers/utils.ts

@@ -0,0 +1,50 @@
+// __STATIC_CONTENT is KVNamespace
+declare const __STATIC_CONTENT: unknown
+declare const __STATIC_CONTENT_MANIFEST: string
+
+export type KVAssetOptions = {
+  manifest?: object | string
+  // namespace is KVNamespace
+  namespace?: unknown
+}
+
+export const getContentFromKVAsset = async (
+  path: string,
+  options?: KVAssetOptions
+): Promise<ReadableStream | null> => {
+  let ASSET_MANIFEST: Record<string, string>
+
+  if (options && options.manifest) {
+    if (typeof options.manifest === 'string') {
+      ASSET_MANIFEST = JSON.parse(options.manifest)
+    } else {
+      ASSET_MANIFEST = options.manifest as Record<string, string>
+    }
+  } else {
+    if (typeof __STATIC_CONTENT_MANIFEST === 'string') {
+      ASSET_MANIFEST = JSON.parse(__STATIC_CONTENT_MANIFEST)
+    } else {
+      ASSET_MANIFEST = __STATIC_CONTENT_MANIFEST
+    }
+  }
+
+  // ASSET_NAMESPACE is KVNamespace
+  let ASSET_NAMESPACE: unknown
+  if (options && options.namespace) {
+    ASSET_NAMESPACE = options.namespace
+  } else {
+    ASSET_NAMESPACE = __STATIC_CONTENT
+  }
+
+  const key = ASSET_MANIFEST[path] || path
+  if (!key) {
+    return null
+  }
+
+  // @ts-expect-error ASSET_NAMESPACE is not typed
+  const content = await ASSET_NAMESPACE.get(key, { type: 'stream' })
+  if (!content) {
+    return null
+  }
+  return content as unknown as ReadableStream
+}

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/cloudflare-workers/websocket.ts

@@ -0,0 +1,50 @@
+import type { UpgradeWebSocket, WSContext, WSReadyState } from '../../helper/websocket'
+
+// Based on https://github.com/honojs/hono/issues/1153#issuecomment-1767321332
+export const upgradeWebSocket: UpgradeWebSocket<WebSocket> = (createEvents) => async (c, next) => {
+  const events = await createEvents(c)
+
+  const upgradeHeader = c.req.header('Upgrade')
+  if (upgradeHeader !== 'websocket') {
+    return await next()
+  }
+
+  // @ts-expect-error WebSocketPair is not typed
+  const webSocketPair = new WebSocketPair()
+  const client: WebSocket = webSocketPair[0]
+  const server: WebSocket = webSocketPair[1]
+
+  const wsContext: WSContext<WebSocket> = {
+    binaryType: 'arraybuffer',
+    close: (code, reason) => server.close(code, reason),
+    get protocol() {
+      return server.protocol
+    },
+    raw: server,
+    get readyState() {
+      return server.readyState as WSReadyState
+    },
+    url: server.url ? new URL(server.url) : null,
+    send: (source) => server.send(source),
+  }
+  if (events.onOpen) {
+    server.addEventListener('open', (evt: Event) => events.onOpen?.(evt, wsContext))
+  }
+  if (events.onClose) {
+    server.addEventListener('close', (evt: CloseEvent) => events.onClose?.(evt, wsContext))
+  }
+  if (events.onMessage) {
+    server.addEventListener('message', (evt: MessageEvent) => events.onMessage?.(evt, wsContext))
+  }
+  if (events.onError) {
+    server.addEventListener('error', (evt: Event) => events.onError?.(evt, wsContext))
+  }
+
+  // @ts-expect-error - server.accept is not typed
+  server.accept?.()
+  return new Response(null, {
+    status: 101,
+    // @ts-expect-error - webSocket is not typed
+    webSocket: client,
+  })
+}

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/deno/conninfo.ts

@@ -0,0 +1,17 @@
+import type { GetConnInfo } from '../../helper/conninfo'
+
+/**
+ * Get conninfo with Deno
+ * @param c Context
+ * @returns ConnInfo
+ */
+export const getConnInfo: GetConnInfo = (c) => {
+  const { remoteAddr } = c.env
+  return {
+    remote: {
+      address: remoteAddr.hostname,
+      port: remoteAddr.port,
+      transport: remoteAddr.transport,
+    },
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/deno/deno.d.ts

@@ -0,0 +1,28 @@
+declare namespace Deno {
+  /**
+   * Creates a new directory with the specified path.
+   *
+   * @param path The path to create a directory.
+   * @param options Options for creating a directory.
+   * @returns A promise that resolves when the directory is created.
+   */
+  export function mkdir(path: string, options?: { recursive?: boolean }): Promise<void>
+
+  /**
+   * Write a new file, with the specified path and data.
+   *
+   * @param path The path to the file to write.
+   * @param data The data to write to the file.
+   * @returns A promise that resolves when the file is written.
+   */
+  export function writeFile(path: string, data: Uint8Array): Promise<void>
+
+  export function upgradeWebSocket(
+    req: Request,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    options: any
+  ): {
+    response: Response
+    socket: WebSocket
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/deno/index.ts

@@ -0,0 +1,9 @@
+/**
+ * @module
+ * Deno Adapter for Hono.
+ */
+
+export { serveStatic } from './serve-static'
+export { toSSG, denoFileSystemModule } from './ssg'
+export { upgradeWebSocket } from './websocket'
+export { getConnInfo } from './conninfo'

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/deno/serve-static.ts

@@ -0,0 +1,40 @@
+import type { ServeStaticOptions } from '../../middleware/serve-static'
+import { serveStatic as baseServeStatic } from '../../middleware/serve-static'
+import type { Env, MiddlewareHandler } from '../../types'
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const { open, lstatSync } = Deno
+
+export const serveStatic = <E extends Env = Env>(
+  options: ServeStaticOptions<E>
+): MiddlewareHandler => {
+  return async function serveStatic(c, next) {
+    const getContent = async (path: string) => {
+      try {
+        const file = await open(path)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return file ? (file.readable as any) : null
+      } catch (e) {
+        console.warn(`${e}`)
+      }
+    }
+    const pathResolve = (path: string) => {
+      return `./${path}`
+    }
+    const isDir = (path: string) => {
+      let isDir
+      try {
+        const stat = lstatSync(path)
+        isDir = stat.isDirectory
+      } catch {}
+      return isDir
+    }
+    return baseServeStatic({
+      ...options,
+      getContent,
+      pathResolve,
+      isDir,
+    })(c, next)
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/deno/ssg.ts

@@ -0,0 +1,27 @@
+import { toSSG as baseToSSG } from '../../helper/ssg/index'
+import type { FileSystemModule, ToSSGAdaptorInterface } from '../../helper/ssg/index'
+
+/**
+ * @experimental
+ * `denoFileSystemModule` is an experimental feature.
+ * The API might be changed.
+ */
+export const denoFileSystemModule: FileSystemModule = {
+  writeFile: async (path, data) => {
+    const uint8Data =
+      typeof data === 'string' ? new TextEncoder().encode(data) : new Uint8Array(data)
+    await Deno.writeFile(path, uint8Data)
+  },
+  mkdir: async (path, options) => {
+    return Deno.mkdir(path, { recursive: options?.recursive ?? false })
+  },
+}
+
+/**
+ * @experimental
+ * `toSSG` is an experimental feature.
+ * The API might be changed.
+ */
+export const toSSG: ToSSGAdaptorInterface = async (app, options) => {
+  return baseToSSG(app, denoFileSystemModule, options)
+}

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/deno/websocket.ts

@@ -0,0 +1,51 @@
+import type { UpgradeWebSocket, WSContext, WSReadyState } from '../../helper/websocket'
+
+export interface UpgradeWebSocketOptions {
+  /**
+   * Sets the `.protocol` property on the client side web socket to the
+   * value provided here, which should be one of the strings specified in the
+   * `protocols` parameter when requesting the web socket. This is intended
+   * for clients and servers to specify sub-protocols to use to communicate to
+   * each other.
+   */
+  protocol?: string
+  /**
+   * If the client does not respond to this frame with a
+   * `pong` within the timeout specified, the connection is deemed
+   * unhealthy and is closed. The `close` and `error` event will be emitted.
+   *
+   * The unit is seconds, with a default of 30.
+   * Set to `0` to disable timeouts.
+   */
+  idleTimeout?: number
+}
+
+export const upgradeWebSocket: UpgradeWebSocket<WebSocket, UpgradeWebSocketOptions> =
+  (createEvents, options) => async (c, next) => {
+    if (c.req.header('upgrade') !== 'websocket') {
+      return await next()
+    }
+
+    const events = await createEvents(c)
+    const { response, socket } = Deno.upgradeWebSocket(c.req.raw, options || {})
+
+    const wsContext: WSContext<WebSocket> = {
+      binaryType: 'arraybuffer',
+      close: (code, reason) => socket.close(code, reason),
+      get protocol() {
+        return socket.protocol
+      },
+      raw: socket,
+      get readyState() {
+        return socket.readyState as WSReadyState
+      },
+      url: socket.url ? new URL(socket.url) : null,
+      send: (source) => socket.send(source),
+    }
+    socket.onopen = (evt) => events.onOpen?.(evt, wsContext)
+    socket.onmessage = (evt) => events.onMessage?.(evt, wsContext)
+    socket.onclose = (evt) => events.onClose?.(evt, wsContext)
+    socket.onerror = (evt) => events.onError?.(evt, wsContext)
+
+    return response
+  }