zastro-websockets-cloudflare 0.0.0-729d313

package/dist/websocket/server.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Cloudflare WebSocket server entrypoint
+ */
+import type { App } from 'astro/app';
+declare global {
+    var WebSocketPair: {
+        new (): {
+            0: CloudflareWebSocket;
+            1: CloudflareWebSocket;
+        };
+    };
+    interface CloudflareWebSocket {
+        send(data: string | ArrayBufferLike | ArrayBufferView): void;
+        close(code?: number, reason?: string): void;
+        accept(): void;
+        addEventListener(type: 'message', listener: (event: {
+            data: any;
+        }) => void): void;
+        addEventListener(type: 'close', listener: (event: {
+            code: number;
+            reason: string;
+            wasClean: boolean;
+        }) => void): void;
+        addEventListener(type: 'error', listener: (event: any) => void): void;
+        addEventListener(type: 'open', listener: (event: any) => void): void;
+        removeEventListener(type: string, listener: any): void;
+        readonly readyState: number;
+        readonly url: string;
+    }
+}
+export type CloudflareApp = App;
+export declare function createWebSocketHandler(app: CloudflareApp): (request: Request, env: any, ctx: any) => Promise<Response>;
+export { WebSocket, attach } from './websocket.js';

package/dist/websocket/server.js

@@ -0,0 +1,57 @@
+import { WebSocket, attach } from "./websocket.js";
+function createWebSocketHandler(app) {
+  return async function handleWebSocket(request, env, ctx) {
+    const upgradeHeader = request.headers.get("upgrade");
+    const connectionHeader = request.headers.get("connection");
+    if (upgradeHeader !== "websocket" || !connectionHeader?.toLowerCase().includes("upgrade")) {
+      return app.render(request, { locals: { isUpgradeRequest: false } });
+    }
+    const webSocketPair = new WebSocketPair();
+    const [client, server] = [webSocketPair[0], webSocketPair[1]];
+    const response = await app.render(request, {
+      locals: {
+        isUpgradeRequest: true,
+        upgradeWebSocket() {
+          const socket = new WebSocket(request.url);
+          attach(socket, server);
+          const upgradeResponse = new Response(null, {
+            status: 101,
+            statusText: "Switching Protocols",
+            headers: {
+              "Upgrade": "websocket",
+              "Connection": "Upgrade"
+            },
+            webSocket: client
+          });
+          return { socket, response: upgradeResponse };
+        },
+        runtime: {
+          env,
+          cf: request.cf,
+          ctx,
+          caches: globalThis.caches,
+          waitUntil: (promise) => ctx.waitUntil(promise)
+        }
+      }
+    });
+    if (response.status === 101 && response.headers.get("upgrade") === "websocket") {
+      server.accept();
+      return new Response(null, {
+        status: 101,
+        statusText: "Switching Protocols",
+        headers: {
+          "Upgrade": "websocket",
+          "Connection": "Upgrade"
+        },
+        webSocket: client
+      });
+    }
+    return response;
+  };
+}
+import { WebSocket as WebSocket2, attach as attach2 } from "./websocket.js";
+export {
+  WebSocket2 as WebSocket,
+  attach2 as attach,
+  createWebSocketHandler
+};

package/dist/websocket/websocket.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Cloudflare WebSocket implementation
+ */
+export interface WebSocketUpgrade {
+    socket: WebSocket;
+    response: Response;
+}
+export declare class WebSocket extends EventTarget {
+    private _ws;
+    private _readyState;
+    private _binaryType;
+    private _url;
+    private _protocol;
+    private _extensions;
+    private _bufferedAmount;
+    static readonly CONNECTING: 0;
+    static readonly OPEN: 1;
+    static readonly CLOSING: 2;
+    static readonly CLOSED: 3;
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    readonly CLOSING: 2;
+    readonly CLOSED: 3;
+    onopen: ((event: Event) => void) | null;
+    onerror: ((event: Event) => void) | null;
+    onclose: ((event: CloseEvent) => void) | null;
+    onmessage: ((event: MessageEvent) => void) | null;
+    constructor(url?: string);
+    get url(): string;
+    get readyState(): number;
+    get bufferedAmount(): number;
+    get extensions(): string;
+    get protocol(): string;
+    get binaryType(): "blob" | "arraybuffer";
+    set binaryType(value: 'blob' | 'arraybuffer');
+    close(code?: number, reason?: string): void;
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+}
+export declare function attach(standard: WebSocket, cfWebSocket: CloudflareWebSocket): void;
+export declare class ErrorEvent extends Event {
+    constructor(type: string, init?: {
+        message?: string;
+    });
+    readonly message: string;
+}
+export declare class CloseEvent extends Event implements globalThis.CloseEvent {
+    readonly code: number;
+    readonly reason: string;
+    readonly wasClean: boolean;
+    constructor(type: string, eventInitDict?: CloseEventInit);
+}
+interface CloseEventInit extends EventInit {
+    code?: number;
+    reason?: string;
+    wasClean?: boolean;
+}
+interface CloudflareWebSocket {
+    send(data: string | ArrayBufferLike | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: 'message', listener: (event: {
+        data: any;
+    }) => void): void;
+    addEventListener(type: 'close', listener: (event: {
+        code: number;
+        reason: string;
+        wasClean: boolean;
+    }) => void): void;
+    addEventListener(type: 'error', listener: (event: any) => void): void;
+    addEventListener(type: 'open', listener: (event: any) => void): void;
+    removeEventListener(type: string, listener: any): void;
+    readonly readyState: number;
+    readonly url: string;
+    accept(): void;
+}
+export {};

package/dist/websocket/websocket.js

@@ -0,0 +1,131 @@
+class WebSocket extends EventTarget {
+  _ws;
+  _readyState = 0;
+  // Use numeric literal instead of static property
+  _binaryType = "blob";
+  _url = "";
+  _protocol = "";
+  _extensions = "";
+  _bufferedAmount = 0;
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  // Instance constants
+  CONNECTING = 0;
+  OPEN = 1;
+  CLOSING = 2;
+  CLOSED = 3;
+  // Event handlers
+  onopen = null;
+  onerror = null;
+  onclose = null;
+  onmessage = null;
+  constructor(url) {
+    super();
+    this._url = url || "";
+  }
+  get url() {
+    return this._url;
+  }
+  get readyState() {
+    return this._readyState;
+  }
+  get bufferedAmount() {
+    return this._bufferedAmount;
+  }
+  get extensions() {
+    return this._extensions;
+  }
+  get protocol() {
+    return this._protocol;
+  }
+  get binaryType() {
+    return this._binaryType;
+  }
+  set binaryType(value) {
+    this._binaryType = value;
+  }
+  close(code, reason) {
+    if (this._readyState === WebSocket.CLOSED || this._readyState === WebSocket.CLOSING) {
+      return;
+    }
+    this._readyState = WebSocket.CLOSING;
+    if (this._ws) {
+      this._ws.close(code, reason);
+    } else {
+      this._readyState = WebSocket.CLOSED;
+      const event = new CloseEvent("close", { code: code || 1e3, reason: reason || "", wasClean: true });
+      this.onclose?.(event);
+      this.dispatchEvent(event);
+    }
+  }
+  send(data) {
+    if (this._readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not open");
+    }
+    if (this._ws) {
+      if (data instanceof Blob) {
+        data.arrayBuffer().then((buffer) => this._ws.send(buffer));
+      } else {
+        this._ws.send(data);
+      }
+    }
+  }
+}
+const wsMap = /* @__PURE__ */ new WeakMap();
+function attach(standard, cfWebSocket) {
+  if (wsMap.has(standard)) {
+    throw new Error("WebSocket already attached");
+  }
+  wsMap.set(standard, cfWebSocket);
+  Object.defineProperty(standard, "_ws", { value: cfWebSocket, writable: true });
+  Object.defineProperty(standard, "_readyState", { value: WebSocket.OPEN, writable: true });
+  cfWebSocket.addEventListener("message", (event) => {
+    const messageEvent = new MessageEvent("message", { data: event.data });
+    standard.onmessage?.(messageEvent);
+    standard.dispatchEvent(messageEvent);
+  });
+  cfWebSocket.addEventListener("close", (event) => {
+    Object.assign(standard, { _readyState: WebSocket.CLOSED });
+    const closeEvent = new CloseEvent("close", {
+      code: event.code,
+      reason: event.reason,
+      wasClean: event.wasClean
+    });
+    standard.onclose?.(closeEvent);
+    standard.dispatchEvent(closeEvent);
+  });
+  cfWebSocket.addEventListener("error", (_event) => {
+    const errorEvent = new ErrorEvent("error", { message: "WebSocket error" });
+    standard.onerror?.(errorEvent);
+    standard.dispatchEvent(errorEvent);
+  });
+  const openEvent = new Event("open");
+  standard.onopen?.(openEvent);
+  standard.dispatchEvent(openEvent);
+}
+class ErrorEvent extends Event {
+  constructor(type, init) {
+    super(type);
+    this.message = init?.message || "";
+  }
+  message;
+}
+class CloseEvent extends Event {
+  code;
+  reason;
+  wasClean;
+  constructor(type, eventInitDict) {
+    super(type, eventInitDict);
+    this.code = eventInitDict?.code ?? 0;
+    this.reason = eventInitDict?.reason ?? "";
+    this.wasClean = eventInitDict?.wasClean ?? false;
+  }
+}
+export {
+  CloseEvent,
+  ErrorEvent,
+  WebSocket,
+  attach
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "zastro-websockets-cloudflare",
+  "description": "Deploy your site to Cloudflare Workers/Pages with WebSocket support",
+  "version": "0.0.0-729d313",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "author": "Zach Handley <zach@zachhandley.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zachhandley/ZAstroWebsockets.git"
+  },
+  "keywords": [
+    "withastro",
+    "astro-adapter",
+    "websockets"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./entrypoints/server.js": "./dist/entrypoints/server.js",
+    "./entrypoints/middleware.js": "./dist/entrypoints/middleware.js",
+    "./image-service": "./dist/entrypoints/image-service.js",
+    "./image-endpoint": "./dist/entrypoints/image-endpoint.js",
+    "./handler": "./dist/utils/handler.js",
+    "./package.json": "./package.json",
+    "./websocket": "./dist/websocket/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@astrojs/internal-helpers": "^0.6.1",
+    "@astrojs/underscore-redirects": "^1.0.0",
+    "@cloudflare/workers-types": "^4.20250507.0",
+    "tinyglobby": "^0.2.13",
+    "vite": "^6.3.5",
+    "wrangler": "^4.14.1"
+  },
+  "peerDependencies": {
+    "astro": "^5.0.0"
+  }
+}