zastro-websockets-cloudflare 0.0.0-729d313

package/dist/utils/cloudflare-module-loader.js

@@ -0,0 +1,175 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as url from "node:url";
+function cloudflareModuleLoader(enabled) {
+  const adaptersByExtension = enabled ? { ...defaultAdapters } : {};
+  const extensions = Object.keys(adaptersByExtension);
+  let isDev = false;
+  const MAGIC_STRING = "__CLOUDFLARE_ASSET__";
+  const replacements = [];
+  return {
+    name: "vite:cf-module-loader",
+    enforce: "pre",
+    configResolved(config) {
+      isDev = config.command === "serve";
+    },
+    config(_, __) {
+      return {
+        assetsInclude: extensions.map((x) => `**/*${x}`),
+        build: {
+          rollupOptions: {
+            // mark the wasm files as external so that they are not bundled and instead are loaded from the files
+            external: extensions.map(
+              (x) => new RegExp(`^${MAGIC_STRING}.+${escapeRegExp(x)}.mjs$`, "i")
+            )
+          }
+        }
+      };
+    },
+    async load(id, _) {
+      const maybeExtension = extensions.find((x) => id.endsWith(x));
+      const moduleType = maybeExtension && adaptersByExtension[maybeExtension] || void 0;
+      if (!moduleType || !maybeExtension) {
+        return;
+      }
+      if (!enabled) {
+        throw new Error(
+          `Cloudflare module loading is experimental. The ${maybeExtension} module cannot be loaded unless you add \`cloudflareModules: true\` to your astro config.`
+        );
+      }
+      const moduleLoader = renderers[moduleType];
+      const filePath = id.replace(/\?\w+$/, "");
+      const extension = maybeExtension.replace(/\?\w+$/, "");
+      const data = await fs.readFile(filePath);
+      const base64 = data.toString("base64");
+      const inlineModule = moduleLoader(data);
+      if (isDev) {
+        return inlineModule;
+      }
+      const hash = hashString(base64);
+      const assetName = `${path.basename(filePath).split(".")[0]}.${hash}${extension}`;
+      this.emitFile({
+        type: "asset",
+        // emit the data explicitly as an esset with `fileName` rather than `name` so that
+        // vite doesn't give it a random hash-id in its name--We need to be able to easily rewrite from
+        // the .mjs loader and the actual wasm asset later in the ESbuild for the worker
+        fileName: assetName,
+        source: data
+      });
+      const chunkId = this.emitFile({
+        type: "prebuilt-chunk",
+        fileName: `${assetName}.mjs`,
+        code: inlineModule
+      });
+      return `import module from "${MAGIC_STRING}${chunkId}${extension}.mjs";export default module;`;
+    },
+    // output original wasm file relative to the chunk now that chunking has been achieved
+    renderChunk(code, chunk, _) {
+      if (isDev) return;
+      if (!code.includes(MAGIC_STRING)) return;
+      let replaced = code;
+      for (const ext of extensions) {
+        const extension = ext.replace(/\?\w+$/, "");
+        replaced = replaced.replaceAll(
+          new RegExp(`${MAGIC_STRING}([^\\s]+?)${escapeRegExp(extension)}\\.mjs`, "g"),
+          (_s, assetId) => {
+            const fileName = this.getFileName(assetId);
+            const relativePath = path.relative(path.dirname(chunk.fileName), fileName).replaceAll("\\", "/");
+            replacements.push({
+              chunkName: chunk.name,
+              cloudflareImport: relativePath.replace(/\.mjs$/, ""),
+              nodejsImport: relativePath
+            });
+            return `./${relativePath}`;
+          }
+        );
+      }
+      return { code: replaced };
+    },
+    generateBundle(_, bundle) {
+      const replacementsByChunkName = /* @__PURE__ */ new Map();
+      for (const replacement of replacements) {
+        const repls = replacementsByChunkName.get(replacement.chunkName) || [];
+        if (!repls.length) {
+          replacementsByChunkName.set(replacement.chunkName, repls);
+        }
+        repls.push(replacement);
+      }
+      for (const chunk of Object.values(bundle)) {
+        const repls = chunk.name && replacementsByChunkName.get(chunk.name);
+        for (const replacement of repls || []) {
+          if (!replacement.fileName) {
+            replacement.fileName = [];
+          }
+          replacement.fileName.push(chunk.fileName);
+        }
+      }
+    },
+    /**
+     * Once prerendering is complete, restore the imports in the _worker.js to cloudflare compatible ones, removing the .mjs suffix.
+     */
+    async afterBuildCompleted(config) {
+      const baseDir = url.fileURLToPath(config.outDir);
+      const replacementsByFileName = /* @__PURE__ */ new Map();
+      for (const replacement of replacements) {
+        if (!replacement.fileName) {
+          continue;
+        }
+        for (const fileName of replacement.fileName) {
+          const repls = replacementsByFileName.get(fileName) || [];
+          if (!repls.length) {
+            replacementsByFileName.set(fileName, repls);
+          }
+          repls.push(replacement);
+        }
+      }
+      for (const [fileName, repls] of replacementsByFileName.entries()) {
+        const filepath = path.join(baseDir, "_worker.js", fileName);
+        const contents = await fs.readFile(filepath, "utf-8");
+        let updated = contents;
+        for (const replacement of repls) {
+          updated = updated.replaceAll(replacement.nodejsImport, replacement.cloudflareImport);
+        }
+        await fs.writeFile(filepath, updated, "utf-8");
+      }
+    }
+  };
+}
+const renderers = {
+  CompiledWasm(fileContents) {
+    const base64 = fileContents.toString("base64");
+    return `const wasmModule = new WebAssembly.Module(Uint8Array.from(atob("${base64}"), c => c.charCodeAt(0)));export default wasmModule;`;
+  },
+  Data(fileContents) {
+    const base64 = fileContents.toString("base64");
+    return `const binModule = Uint8Array.from(atob("${base64}"), c => c.charCodeAt(0)).buffer;export default binModule;`;
+  },
+  Text(fileContents) {
+    const escaped = JSON.stringify(fileContents.toString("utf-8"));
+    return `const stringModule = ${escaped};export default stringModule;`;
+  }
+};
+const defaultAdapters = {
+  // Loads '*.wasm?module' imports as WebAssembly modules, which is the only way to load WASM in cloudflare workers.
+  // Current proposal for WASM modules: https://github.com/WebAssembly/esm-integration/tree/main/proposals/esm-integration
+  ".wasm?module": "CompiledWasm",
+  // treats the module as a WASM module
+  ".wasm": "CompiledWasm",
+  ".bin": "Data",
+  ".txt": "Text"
+};
+function hashString(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash &= hash;
+  }
+  return new Uint32Array([hash])[0].toString(36);
+}
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export {
+  cloudflareModuleLoader
+};

package/dist/utils/env.d.ts

@@ -0,0 +1,2 @@
+import type { GetEnv } from 'astro/env/setup';
+export declare const createGetEnv: (env: Record<string, unknown>) => GetEnv;

package/dist/utils/env.js

@@ -0,0 +1,13 @@
+const createGetEnv = (env) => (key) => {
+  const v = env[key];
+  if (typeof v === "undefined" || typeof v === "string") {
+    return v;
+  }
+  if (typeof v === "boolean" || typeof v === "number") {
+    return v.toString();
+  }
+  return void 0;
+};
+export {
+  createGetEnv
+};

package/dist/utils/generate-routes-json.d.ts

@@ -0,0 +1,9 @@
+import type { AstroConfig, AstroIntegrationLogger, IntegrationResolvedRoute, RoutePart } from 'astro';
+export declare function getParts(part: string): RoutePart[];
+export declare function createRoutesFile(_config: AstroConfig, logger: AstroIntegrationLogger, routes: IntegrationResolvedRoute[], pages: {
+    pathname: string;
+}[], redirects: IntegrationResolvedRoute['segments'][], includeExtends: {
+    pattern: string;
+}[] | undefined, excludeExtends: {
+    pattern: string;
+}[] | undefined): Promise<void>;

package/dist/utils/generate-routes-json.js

@@ -0,0 +1,225 @@
+import { existsSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  prependForwardSlash,
+  removeLeadingForwardSlash,
+  removeTrailingForwardSlash
+} from "@astrojs/internal-helpers/path";
+import { glob } from "tinyglobby";
+const ROUTE_DYNAMIC_SPLIT = /\[(.+?\(.+?\)|.+?)\]/;
+const ROUTE_SPREAD = /^\.{3}.+$/;
+function getParts(part) {
+  const result = [];
+  part.split(ROUTE_DYNAMIC_SPLIT).map((str, i) => {
+    if (!str) return;
+    const dynamic = i % 2 === 1;
+    const [, content] = dynamic ? /([^(]+)$/.exec(str) || [null, null] : [null, str];
+    if (!content || dynamic && !/^(?:\.\.\.)?[\w$]+$/.test(content)) {
+      throw new Error("Parameter name must match /^[a-zA-Z0-9_$]+$/");
+    }
+    result.push({
+      content,
+      dynamic,
+      spread: dynamic && ROUTE_SPREAD.test(content)
+    });
+  });
+  return result;
+}
+async function writeRoutesFileToOutDir(_config, logger, include, exclude) {
+  try {
+    await writeFile(
+      new URL("./_routes.json", _config.outDir),
+      JSON.stringify(
+        {
+          version: 1,
+          include,
+          exclude
+        },
+        null,
+        2
+      ),
+      "utf-8"
+    );
+  } catch (_error) {
+    logger.error("There was an error writing the '_routes.json' file to the output directory.");
+  }
+}
+function segmentsToCfSyntax(segments, _config) {
+  const pathSegments = [];
+  if (removeLeadingForwardSlash(removeTrailingForwardSlash(_config.base)).length > 0) {
+    pathSegments.push(removeLeadingForwardSlash(removeTrailingForwardSlash(_config.base)));
+  }
+  for (const segment of segments.flat()) {
+    if (segment.dynamic) pathSegments.push("*");
+    else pathSegments.push(segment.content);
+  }
+  return pathSegments;
+}
+class TrieNode {
+  children = /* @__PURE__ */ new Map();
+  isEndOfPath = false;
+  hasWildcardChild = false;
+}
+class PathTrie {
+  root;
+  returnHasWildcard = false;
+  constructor() {
+    this.root = new TrieNode();
+  }
+  insert(thisPath) {
+    let node = this.root;
+    for (const segment of thisPath) {
+      if (segment === "*") {
+        node.hasWildcardChild = true;
+        break;
+      }
+      if (!node.children.has(segment)) {
+        node.children.set(segment, new TrieNode());
+      }
+      node = node.children.get(segment);
+    }
+    node.isEndOfPath = true;
+  }
+  /**
+   * Depth-first search (dfs), traverses the "graph"  segment by segment until the end or wildcard (*).
+   * It makes sure that all necessary paths are returned, but not paths with an existing wildcard prefix.
+   * e.g. if we have a path like /foo/* and /foo/bar, we only want to return /foo/*
+   */
+  dfs(node, thisPath, allPaths) {
+    if (node.hasWildcardChild) {
+      this.returnHasWildcard = true;
+      allPaths.push([...thisPath, "*"]);
+      return;
+    }
+    if (node.isEndOfPath) {
+      allPaths.push([...thisPath]);
+    }
+    for (const [segment, childNode] of node.children) {
+      this.dfs(childNode, [...thisPath, segment], allPaths);
+    }
+  }
+  /**
+   * The reduce function is used to remove unnecessary paths from the trie.
+   * It receives a trie node to compare with the current node.
+   */
+  reduce(compNode, node) {
+    if (node.hasWildcardChild || compNode.hasWildcardChild) return;
+    for (const [segment, childNode] of node.children) {
+      if (childNode.children.size === 0) continue;
+      const compChildNode = compNode.children.get(segment);
+      if (compChildNode === void 0) {
+        childNode.hasWildcardChild = true;
+        continue;
+      }
+      this.reduce(compChildNode, childNode);
+    }
+  }
+  reduceAllPaths(compTrie) {
+    this.reduce(compTrie.root, this.root);
+    return this;
+  }
+  getAllPaths() {
+    const allPaths = [];
+    this.dfs(this.root, [], allPaths);
+    return [allPaths, this.returnHasWildcard];
+  }
+}
+async function createRoutesFile(_config, logger, routes, pages, redirects, includeExtends, excludeExtends) {
+  const includePaths = [];
+  const excludePaths = [];
+  const assetsPath = segmentsToCfSyntax(
+    [
+      [{ content: _config.build.assets, dynamic: false, spread: false }],
+      [{ content: "", dynamic: true, spread: false }]
+    ],
+    _config
+  );
+  excludePaths.push(assetsPath);
+  for (const redirect of redirects) {
+    excludePaths.push(segmentsToCfSyntax(redirect, _config));
+  }
+  if (existsSync(fileURLToPath(_config.publicDir))) {
+    const staticFiles = await glob(`**/*`, {
+      cwd: fileURLToPath(_config.publicDir),
+      dot: true
+    });
+    for (const staticFile of staticFiles) {
+      if (["_headers", "_redirects", "_routes.json"].includes(staticFile)) continue;
+      const staticPath = staticFile;
+      const segments = removeLeadingForwardSlash(staticPath).split(path.sep).filter(Boolean).map((s) => {
+        return getParts(s);
+      });
+      excludePaths.push(segmentsToCfSyntax(segments, _config));
+    }
+  }
+  let hasPrerendered404 = false;
+  for (const route of routes) {
+    const convertedPath = segmentsToCfSyntax(route.segments, _config);
+    if (route.pathname === "/404" && route.isPrerendered === true) hasPrerendered404 = true;
+    switch (route.type) {
+      case "page":
+        if (route.isPrerendered === false) includePaths.push(convertedPath);
+        break;
+      case "endpoint":
+        if (route.isPrerendered === false) includePaths.push(convertedPath);
+        else excludePaths.push(convertedPath);
+        break;
+      case "redirect":
+        excludePaths.push(convertedPath);
+        break;
+      default:
+        includePaths.push(convertedPath);
+        break;
+    }
+  }
+  for (const page of pages) {
+    if (page.pathname === "404") hasPrerendered404 = true;
+    const pageSegments = removeLeadingForwardSlash(page.pathname).split(path.posix.sep).filter(Boolean).map((s) => {
+      return getParts(s);
+    });
+    excludePaths.push(segmentsToCfSyntax(pageSegments, _config));
+  }
+  const includeTrie = new PathTrie();
+  for (const includePath of includePaths) {
+    includeTrie.insert(includePath);
+  }
+  const excludeTrie = new PathTrie();
+  for (const excludePath of excludePaths) {
+    if (excludePath[0] === "*") continue;
+    excludeTrie.insert(excludePath);
+  }
+  const [deduplicatedIncludePaths, includedPathsHaveWildcard] = includeTrie.reduceAllPaths(excludeTrie).getAllPaths();
+  const [deduplicatedExcludePaths, _excludedPathsHaveWildcard] = excludeTrie.reduceAllPaths(includeTrie).getAllPaths();
+  const CLOUDFLARE_COMBINED_LIMIT = 100;
+  const AUTOMATIC_INCLUDE_RULES_COUNT = deduplicatedIncludePaths.length;
+  const EXTENDED_INCLUDE_RULES_COUNT = includeExtends?.length ?? 0;
+  const INCLUDE_RULES_COUNT = AUTOMATIC_INCLUDE_RULES_COUNT + EXTENDED_INCLUDE_RULES_COUNT;
+  const AUTOMATIC_EXCLUDE_RULES_COUNT = deduplicatedExcludePaths.length;
+  const EXTENDED_EXCLUDE_RULES_COUNT = excludeExtends?.length ?? 0;
+  const EXCLUDE_RULES_COUNT = AUTOMATIC_EXCLUDE_RULES_COUNT + EXTENDED_EXCLUDE_RULES_COUNT;
+  const OPTION2_TOTAL_COUNT = INCLUDE_RULES_COUNT + (includedPathsHaveWildcard ? EXCLUDE_RULES_COUNT : 0);
+  if (!hasPrerendered404 || OPTION2_TOTAL_COUNT > CLOUDFLARE_COMBINED_LIMIT) {
+    await writeRoutesFileToOutDir(
+      _config,
+      logger,
+      ["/*"].concat(includeExtends?.map((entry) => entry.pattern) ?? []),
+      deduplicatedExcludePaths.map((thisPath) => `${prependForwardSlash(thisPath.join("/"))}`).slice(
+        0,
+        CLOUDFLARE_COMBINED_LIMIT - EXTENDED_INCLUDE_RULES_COUNT - EXTENDED_EXCLUDE_RULES_COUNT - 1
+      ).concat(excludeExtends?.map((entry) => entry.pattern) ?? [])
+    );
+  } else {
+    await writeRoutesFileToOutDir(
+      _config,
+      logger,
+      deduplicatedIncludePaths.map((thisPath) => `${prependForwardSlash(thisPath.join("/"))}`).concat(includeExtends?.map((entry) => entry.pattern) ?? []),
+      includedPathsHaveWildcard ? deduplicatedExcludePaths.map((thisPath) => `${prependForwardSlash(thisPath.join("/"))}`).concat(excludeExtends?.map((entry) => entry.pattern) ?? []) : []
+    );
+  }
+}
+export {
+  createRoutesFile,
+  getParts
+};

package/dist/utils/handler.d.ts

@@ -0,0 +1,24 @@
+import type { CacheStorage as CloudflareCacheStorage, ExecutionContext, ExportedHandlerFetchHandler } from '@cloudflare/workers-types';
+import type { SSRManifest } from 'astro';
+import type { App } from 'astro/app';
+type Env = {
+    [key: string]: unknown;
+    ASSETS: {
+        fetch: (req: Request | string) => Promise<Response>;
+    };
+    ASTRO_STUDIO_APP_TOKEN?: string;
+};
+export interface Runtime<T extends object = object> {
+    runtime: {
+        env: Env & T;
+        cf: Parameters<ExportedHandlerFetchHandler>[0]['cf'];
+        caches: CloudflareCacheStorage;
+        ctx: ExecutionContext;
+    };
+}
+declare global {
+    var __ASTRO_SESSION_BINDING_NAME: string;
+    var __env__: Partial<Env>;
+}
+export declare function handle(manifest: SSRManifest, app: App, request: Parameters<ExportedHandlerFetchHandler>[0], env: Env, context: ExecutionContext): Promise<Response>;
+export {};

package/dist/utils/handler.js

@@ -0,0 +1,64 @@
+import { env as globalEnv } from "cloudflare:workers";
+import { setGetEnv } from "astro/env/setup";
+import { createGetEnv } from "../utils/env.js";
+setGetEnv(createGetEnv(globalEnv));
+async function handle(manifest, app, request, env, context) {
+  const { pathname } = new URL(request.url);
+  const bindingName = globalThis.__ASTRO_SESSION_BINDING_NAME;
+  globalThis.__env__ ??= {};
+  globalThis.__env__[bindingName] = env[bindingName];
+  if (manifest.assets.has(pathname)) {
+    return env.ASSETS.fetch(request.url.replace(/\.html$/, ""));
+  }
+  const routeData = app.match(request);
+  if (!routeData) {
+    const asset = await env.ASSETS.fetch(
+      request.url.replace(/index.html$/, "").replace(/\.html$/, "")
+    );
+    if (asset.status !== 404) {
+      return asset;
+    }
+  }
+  Reflect.set(request, Symbol.for("astro.clientAddress"), request.headers.get("cf-connecting-ip"));
+  process.env.ASTRO_STUDIO_APP_TOKEN ??= (() => {
+    if (typeof env.ASTRO_STUDIO_APP_TOKEN === "string") {
+      return env.ASTRO_STUDIO_APP_TOKEN;
+    }
+  })();
+  const locals = {
+    runtime: {
+      env,
+      cf: request.cf,
+      caches,
+      ctx: {
+        waitUntil: (promise) => context.waitUntil(promise),
+        // Currently not available: https://developers.cloudflare.com/pages/platform/known-issues/#pages-functions
+        passThroughOnException: () => {
+          throw new Error(
+            "`passThroughOnException` is currently not available in Cloudflare Pages. See https://developers.cloudflare.com/pages/platform/known-issues/#pages-functions."
+          );
+        },
+        props: {}
+      }
+    }
+  };
+  const response = await app.render(
+    request,
+    {
+      routeData,
+      locals,
+      prerenderedErrorPageFetch: async (url) => {
+        return env.ASSETS.fetch(url.replace(/\.html$/, ""));
+      }
+    }
+  );
+  if (app.setCookieHeaders) {
+    for (const setCookieHeader of app.setCookieHeaders(response)) {
+      response.headers.append("Set-Cookie", setCookieHeader);
+    }
+  }
+  return response;
+}
+export {
+  handle
+};

package/dist/utils/image-config.d.ts

@@ -0,0 +1,38 @@
+import type { AstroConfig, AstroIntegrationLogger, HookParameters } from 'astro';
+export type ImageService = 'passthrough' | 'cloudflare' | 'compile' | 'custom';
+export declare function setImageConfig(service: ImageService, config: AstroConfig['image'], command: HookParameters<'astro:config:setup'>['command'], logger: AstroIntegrationLogger): {
+    service: import("astro").ImageServiceConfig<Record<string, any>>;
+    responsiveStyles: boolean;
+    endpoint: {
+        route: string;
+        entrypoint?: string | undefined;
+    };
+    domains: string[];
+    remotePatterns: {
+        port?: string | undefined;
+        protocol?: string | undefined;
+        hostname?: string | undefined;
+        pathname?: string | undefined;
+    }[];
+    layout?: "fixed" | "constrained" | "full-width" | "none" | undefined;
+    objectFit?: string | undefined;
+    objectPosition?: string | undefined;
+    breakpoints?: number[] | undefined;
+} | {
+    service: import("astro").ImageServiceConfig<Record<string, any>>;
+    endpoint: {
+        entrypoint: string | undefined;
+    };
+    responsiveStyles: boolean;
+    domains: string[];
+    remotePatterns: {
+        port?: string | undefined;
+        protocol?: string | undefined;
+        hostname?: string | undefined;
+        pathname?: string | undefined;
+    }[];
+    layout?: "fixed" | "constrained" | "full-width" | "none" | undefined;
+    objectFit?: string | undefined;
+    objectPosition?: string | undefined;
+    breakpoints?: number[] | undefined;
+};

package/dist/utils/image-config.js

@@ -0,0 +1,33 @@
+import { passthroughImageService, sharpImageService } from "astro/config";
+function setImageConfig(service, config, command, logger) {
+  switch (service) {
+    case "passthrough":
+      return { ...config, service: passthroughImageService() };
+    case "cloudflare":
+      return {
+        ...config,
+        service: command === "dev" ? sharpImageService() : { entrypoint: "zastro-websockets-cloudflare/image-service" }
+      };
+    case "compile":
+      return {
+        ...config,
+        service: sharpImageService(),
+        endpoint: {
+          entrypoint: command === "dev" ? void 0 : "zastro-websockets-cloudflare/image-endpoint"
+        }
+      };
+    case "custom":
+      return { ...config };
+    default:
+      if (config.service.entrypoint === "astro/assets/services/sharp") {
+        logger.warn(
+          `The current configuration does not support image optimization. To allow your project to build with the original, unoptimized images, the image service has been automatically switched to the 'passthrough' option. See https://docs.astro.build/en/reference/configuration-reference/#imageservice`
+        );
+        return { ...config, service: passthroughImageService() };
+      }
+      return { ...config };
+  }
+}
+export {
+  setImageConfig
+};

package/dist/websocket/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Cloudflare WebSocket exports
+ */
+export { WebSocket, attach, ErrorEvent, CloseEvent } from './websocket.js';
+export { onRequest } from './middleware.js';
+export { createWebSocketHandler } from './server.js';

package/dist/websocket/index.js

@@ -0,0 +1,11 @@
+import { WebSocket, attach, ErrorEvent, CloseEvent } from "./websocket.js";
+import { onRequest } from "./middleware.js";
+import { createWebSocketHandler } from "./server.js";
+export {
+  CloseEvent,
+  ErrorEvent,
+  WebSocket,
+  attach,
+  createWebSocketHandler,
+  onRequest
+};

package/dist/websocket/middleware.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Cloudflare WebSocket middleware
+ */
+import { WebSocket } from './websocket.js';
+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 interface CloudflareLocals {
+    isUpgradeRequest: boolean;
+    upgradeWebSocket(): {
+        socket: WebSocket;
+        response: Response;
+    };
+    runtime?: {
+        env: any;
+        cf: any;
+        ctx: any;
+        caches: any;
+        waitUntil: (promise: Promise<any>) => void;
+    };
+}
+export declare const onRequest: (context: any, next: () => Promise<Response>) => Promise<Response>;

package/dist/websocket/middleware.js

@@ -0,0 +1,29 @@
+import { WebSocket, attach } from "./websocket.js";
+const onRequest = async function cloudflareWebSocketMiddleware(context, next) {
+  const { request, locals } = context;
+  const isUpgradeRequest = request.headers.get("upgrade") === "websocket" && request.headers.get("connection")?.toLowerCase().includes("upgrade");
+  locals.isUpgradeRequest = isUpgradeRequest;
+  locals.upgradeWebSocket = () => {
+    if (!isUpgradeRequest) {
+      throw new Error("The request must be an upgrade request to upgrade the connection to a WebSocket.");
+    }
+    const webSocketPair = new WebSocketPair();
+    const [client, server] = [webSocketPair[0], webSocketPair[1]];
+    const socket = new WebSocket(request.url);
+    attach(socket, server);
+    const response = new Response(null, {
+      status: 101,
+      statusText: "Switching Protocols",
+      headers: {
+        "Upgrade": "websocket",
+        "Connection": "Upgrade"
+      },
+      webSocket: client
+    });
+    return { socket, response };
+  };
+  return next();
+};
+export {
+  onRequest
+};