Aktueller Stand

backend/node_modules/hono/dist/adapter/bun/conninfo.js

@@ -0,0 +1,27 @@
+// src/adapter/bun/conninfo.ts
+import { getBunServer } from "./server.js";
+var getConnInfo = (c) => {
+  const server = getBunServer(c);
+  if (!server) {
+    throw new TypeError("env has to include the 2nd argument of fetch.");
+  }
+  if (typeof server.requestIP !== "function") {
+    throw new TypeError("server.requestIP is not a function.");
+  }
+  const info = server.requestIP(c.req.raw);
+  if (!info) {
+    return {
+      remote: {}
+    };
+  }
+  return {
+    remote: {
+      address: info.address,
+      addressType: info.family === "IPv6" || info.family === "IPv4" ? info.family : void 0,
+      port: info.port
+    }
+  };
+};
+export {
+  getConnInfo
+};

backend/node_modules/hono/dist/adapter/bun/index.js

@@ -0,0 +1,14 @@
+// src/adapter/bun/index.ts
+import { serveStatic } from "./serve-static.js";
+import { bunFileSystemModule, toSSG } from "./ssg.js";
+import { createBunWebSocket, upgradeWebSocket, websocket } from "./websocket.js";
+import { getConnInfo } from "./conninfo.js";
+export {
+  bunFileSystemModule,
+  createBunWebSocket,
+  getConnInfo,
+  serveStatic,
+  toSSG,
+  upgradeWebSocket,
+  websocket
+};

backend/node_modules/hono/dist/adapter/bun/serve-static.js

@@ -0,0 +1,30 @@
+// src/adapter/bun/serve-static.ts
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+import { serveStatic as baseServeStatic } from "../../middleware/serve-static/index.js";
+var serveStatic = (options) => {
+  return async function serveStatic2(c, next) {
+    const getContent = async (path) => {
+      const file = Bun.file(path);
+      return await file.exists() ? file : null;
+    };
+    const isDir = async (path) => {
+      let isDir2;
+      try {
+        const stats = await stat(path);
+        isDir2 = stats.isDirectory();
+      } catch {
+      }
+      return isDir2;
+    };
+    return baseServeStatic({
+      ...options,
+      getContent,
+      join,
+      isDir
+    })(c, next);
+  };
+};
+export {
+  serveStatic
+};

backend/node_modules/hono/dist/adapter/bun/server.js

@@ -0,0 +1,5 @@
+// src/adapter/bun/server.ts
+var getBunServer = (c) => "server" in c.env ? c.env.server : c.env;
+export {
+  getBunServer
+};

backend/node_modules/hono/dist/adapter/bun/ssg.js

@@ -0,0 +1,17 @@
+// src/adapter/bun/ssg.ts
+import { toSSG as baseToSSG } from "../../helper/ssg/index.js";
+var { write } = Bun;
+var bunFileSystemModule = {
+  writeFile: async (path, data) => {
+    await write(path, data);
+  },
+  mkdir: async () => {
+  }
+};
+var toSSG = async (app, options) => {
+  return baseToSSG(app, bunFileSystemModule, options);
+};
+export {
+  bunFileSystemModule,
+  toSSG
+};

backend/node_modules/hono/dist/adapter/bun/websocket.js

@@ -0,0 +1,71 @@
+// src/adapter/bun/websocket.ts
+import { createWSMessageEvent, defineWebSocketHelper, WSContext } from "../../helper/websocket/index.js";
+import { getBunServer } from "./server.js";
+var createWSContext = (ws) => {
+  return new WSContext({
+    send: (source, options) => {
+      ws.send(source, options?.compress);
+    },
+    raw: ws,
+    readyState: ws.readyState,
+    url: ws.data.url,
+    protocol: ws.data.protocol,
+    close(code, reason) {
+      ws.close(code, reason);
+    }
+  });
+};
+var upgradeWebSocket = defineWebSocketHelper((c, events) => {
+  const server = getBunServer(c);
+  if (!server) {
+    throw new TypeError("env has to include the 2nd argument of fetch.");
+  }
+  const upgradeResult = server.upgrade(c.req.raw, {
+    data: {
+      events,
+      url: new URL(c.req.url),
+      protocol: c.req.url
+    }
+  });
+  if (upgradeResult) {
+    return new Response(null);
+  }
+  return;
+});
+var websocket = {
+  open(ws) {
+    const websocketListeners = ws.data.events;
+    if (websocketListeners.onOpen) {
+      websocketListeners.onOpen(new Event("open"), createWSContext(ws));
+    }
+  },
+  close(ws, code, reason) {
+    const websocketListeners = ws.data.events;
+    if (websocketListeners.onClose) {
+      websocketListeners.onClose(
+        new CloseEvent("close", {
+          code,
+          reason
+        }),
+        createWSContext(ws)
+      );
+    }
+  },
+  message(ws, message) {
+    const websocketListeners = ws.data.events;
+    if (websocketListeners.onMessage) {
+      const normalizedReceiveData = typeof message === "string" ? message : message.buffer;
+      websocketListeners.onMessage(createWSMessageEvent(normalizedReceiveData), createWSContext(ws));
+    }
+  }
+};
+var createBunWebSocket = () => ({
+  upgradeWebSocket,
+  websocket
+});
+export {
+  createBunWebSocket,
+  createWSContext,
+  upgradeWebSocket,
+  websocket
+};