@lovrozagar/honey 0.1.0

package/src/ws/node.ts

@@ -0,0 +1,161 @@
+export {
+	type RawSocket,
+	type WSAdapter,
+	type WSContext,
+	WSContextImpl,
+	type WSHandler,
+} from "./cloudflare.ts"
+
+import type { WSAdapter, WSHandler } from "./cloudflare.ts"
+import { WSContextImpl } from "./cloudflare.ts"
+
+type WsModule = {
+	WebSocketServer: new (opts: {
+		noServer: true
+		perMessageDeflate: boolean
+	}) => {
+		handleUpgrade(req: unknown, socket: unknown, head: unknown, cb: (ws: NodeWS) => void): void
+	}
+}
+
+type NodeWS = {
+	close(code?: number, reason?: string): void
+	on(event: "close", cb: (code: number, reason: Buffer) => void): void
+	on(event: "error", cb: (err: unknown) => void): void
+	on(event: "message", cb: (data: Buffer | ArrayBuffer | Buffer[], isBinary: boolean) => void): void
+	on(event: "pong", cb: () => void): void
+	ping(): void
+	readyState: number
+	send(data: ArrayBuffer | Buffer | Uint8Array | string): void
+}
+
+type NodeUpgradeData = {
+	head: Buffer
+	req: unknown
+	socket: unknown
+}
+
+/**
+ * Node.js WebSocket adapter.
+ * Requires the `ws` package. Creates a no-server WebSocketServer internally.
+ * Reads __nodeUpgrade from env (placed there by serve()).
+ */
+type WssInstance = {
+	handleUpgrade(req: unknown, socket: unknown, head: unknown, cb: (ws: NodeWS) => void): void
+}
+
+type KeepaliveConfig = {
+	interval: number
+	timeout: number
+}
+
+export function nodeWebSocket(opts?: { keepalive?: KeepaliveConfig }): WSAdapter {
+	let wss: WssInstance | null = null
+	let wssReady: Promise<void> | null = null
+
+	const ensureWss = async (): Promise<WssInstance> => {
+		if (wss) return wss
+		if (!wssReady) {
+			wssReady = import("ws").then((mod) => {
+				const wsModule = mod as unknown as WsModule
+				wss = new wsModule.WebSocketServer({ noServer: true, perMessageDeflate: false })
+			})
+		}
+		await wssReady
+		if (!wss) throw new Error("Failed to initialize WebSocketServer")
+		return wss
+	}
+
+	return {
+		async upgrade(_req: Request, env: unknown, handler: WSHandler<unknown>) {
+			const server = await ensureWss()
+
+			const nodeEnv = env as Record<string, unknown>
+			const upgrade = nodeEnv.__nodeUpgrade as NodeUpgradeData
+
+			return new Promise((resolve, reject) => {
+				try {
+					server.handleUpgrade(upgrade.req, upgrade.socket, upgrade.head, (ws: NodeWS) => {
+						const socket = new WSContextImpl(ws)
+
+						ws.on("message", (data: Buffer | ArrayBuffer | Buffer[], isBinary: boolean) => {
+							if (!isBinary) {
+								/* text frame — decode to string to match other runtimes */
+								const text = Buffer.isBuffer(data) ? data.toString("utf-8") : String(data)
+								handler.onMessage?.(undefined, socket, text)
+							} else if (Buffer.isBuffer(data)) {
+								/* binary frame — slice from pool to get exact bytes */
+								handler.onMessage?.(
+									undefined,
+									socket,
+									data.buffer.slice(
+										data.byteOffset,
+										data.byteOffset + data.byteLength,
+									) as ArrayBuffer,
+								)
+							} else if (Array.isArray(data)) {
+								const merged = Buffer.concat(data)
+								handler.onMessage?.(
+									undefined,
+									socket,
+									merged.buffer.slice(
+										merged.byteOffset,
+										merged.byteOffset + merged.byteLength,
+									) as ArrayBuffer,
+								)
+							} else {
+								handler.onMessage?.(undefined, socket, data)
+							}
+						})
+
+						/* keepalive ping/pong */
+						let pingTimer: ReturnType<typeof setInterval> | undefined
+						let pongTimeout: ReturnType<typeof setTimeout> | undefined
+
+						if (opts?.keepalive) {
+							const { interval, timeout } = opts.keepalive
+							ws.on("pong", () => {
+								if (pongTimeout !== undefined) {
+									clearTimeout(pongTimeout)
+									pongTimeout = undefined
+								}
+							})
+							pingTimer = setInterval(() => {
+								if (ws.readyState !== 1) {
+									clearInterval(pingTimer)
+									return
+								}
+								ws.ping()
+								pongTimeout = setTimeout(() => {
+									ws.close(1001, "keepalive timeout")
+								}, timeout)
+							}, interval)
+						}
+
+						ws.on("close", (code: number, reason: Buffer) => {
+							if (pingTimer !== undefined) clearInterval(pingTimer)
+							if (pongTimeout !== undefined) clearTimeout(pongTimeout)
+							handler.onClose?.(undefined, socket, code, reason.toString())
+						})
+
+						ws.on("error", (err: unknown) => {
+							if (pingTimer !== undefined) clearInterval(pingTimer)
+							if (pongTimeout !== undefined) clearTimeout(pongTimeout)
+							handler.onError?.(undefined, socket, err)
+						})
+
+						handler.onOpen?.(undefined, socket)
+
+						/* Node's Response rejects status 101 (Fetch spec: 200-599 only).
+						   Create a valid Response and override status for the sentinel check. */
+						const resp = new Response(null)
+						Object.defineProperty(resp, "status", { value: 101 })
+						resolve({ response: resp, socket })
+					})
+				} catch (err) {
+					reject(err)
+				}
+			})
+		},
+	}
+}

package/src/yaml.ts

@@ -0,0 +1,80 @@
+/** JSON-compatible YAML 1.2 emitter — same document as JSON.stringify, different encoding. */
+
+const INDENT = "  "
+
+export function yamlSiblingPath(jsonPath: string): string {
+	if (jsonPath.endsWith(".yaml") || jsonPath.endsWith(".yml")) return jsonPath.replace(/\.yml$/, ".yaml")
+	return jsonPath.endsWith(".json") ? `${jsonPath.slice(0, -5)}.yaml` : `${jsonPath}.yaml`
+}
+
+export function toYaml(value: unknown): string {
+	return `${emit(value, 0)}\n`
+}
+
+function emit(value: unknown, indent: number): string {
+	if (value === null || value === undefined) return "null"
+	if (typeof value === "boolean") return value ? "true" : "false"
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) return JSON.stringify(String(value))
+		return Object.is(value, -0) ? "-0" : String(value)
+	}
+	if (typeof value === "string") return emitString(value)
+	if (Array.isArray(value)) return emitArray(value, indent)
+	if (typeof value === "object") return emitObject(value as Record<string, unknown>, indent)
+	return JSON.stringify(String(value))
+}
+
+function emitString(value: string): string {
+	if (value === "") return '""'
+	if (needsQuotes(value)) return JSON.stringify(value)
+	return value
+}
+
+function needsQuotes(value: string): boolean {
+	if (/^[-?:{},[\],&*#|!>'%@`]/.test(value)) return true
+	if (/[\n\r\t]/.test(value)) return true
+	if (/^\s|\s$/.test(value)) return true
+	if (value.includes(": ") || value.includes(" #")) return true
+	if (/^(true|false|null|yes|no|on|off)$/i.test(value)) return true
+	if (/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(value)) return true
+	if (/^\d/.test(value)) return true
+	return false
+}
+
+function isNonEmptyCollection(value: unknown): boolean {
+	if (Array.isArray(value)) return value.length > 0
+	return value !== null && typeof value === "object" && Object.keys(value).length > 0
+}
+
+function emitArray(value: unknown[], indent: number): string {
+	if (value.length === 0) return "[]"
+	const pad = INDENT.repeat(indent)
+	const childPad = INDENT.repeat(indent + 1)
+	return value
+		.map((item) => {
+			if (isNonEmptyCollection(item)) {
+				const inner = emit(item, indent + 1)
+				const lines = inner.split("\n")
+				const first = lines[0]?.startsWith(childPad) ? lines[0].slice(childPad.length) : (lines[0] ?? "")
+				return [`${pad}- ${first}`, ...lines.slice(1)].join("\n")
+			}
+			return `${pad}- ${emit(item, 0)}`
+		})
+		.join("\n")
+}
+
+function emitObject(value: Record<string, unknown>, indent: number): string {
+	const keys = Object.keys(value)
+	if (keys.length === 0) return "{}"
+	const pad = INDENT.repeat(indent)
+	return keys
+		.map((key) => {
+			const child = value[key]
+			const renderedKey = needsQuotes(key) || key === "" ? JSON.stringify(key) : key
+			if (isNonEmptyCollection(child)) {
+				return `${pad}${renderedKey}:\n${emit(child, indent + 1)}`
+			}
+			return `${pad}${renderedKey}: ${emit(child, 0)}`
+		})
+		.join("\n")
+}