msw-ssr-interceptor/dist/chunk-VSRUD3K7.js

Helper to use msw in SSR environments

import {
  ClientMessage,
  ServerMessage,
  createWebsocketClient,
  init_cjs_shim
} from "./chunk-UYS3OIL5.js";

// src/lib/client.ts
init_cjs_shim();
import crypto from "node:crypto";
import { passthrough } from "msw";
function helper(method) {
  return function register(path, resolver, options = {}) {
    return { method, path, resolver, options };
  };
}
var http = {
  all: helper("all"),
  get: helper("get"),
  post: helper("post"),
  put: helper("put"),
  patch: helper("patch"),
  delete: helper("delete"),
  options: helper("options"),
  head: helper("head")
};
var IDENTIFIER = Symbol("msw:id");
async function setupInterceptor() {
  const router = /* @__PURE__ */ new Map();
  const socket = await createWebsocketClient({
    requests: ServerMessage,
    responses: ClientMessage
  });
  socket.on("server:handler:handle", async ({ id, context }) => {
    const config = router.get(id);
    if (config) {
      const response = await config.resolver(context);
      socket.send("server:handler:handled", response);
    } else {
      socket.send("server:handler:handled", passthrough());
    }
  });
  return {
    async close() {
      return await socket.close();
    },
    use(...handlers) {
      const configs = [];
      for (const { resolver, ...handler } of handlers) {
        const registered = registerResolver(resolver);
        const resolverId = registered.__resolverId__;
        configs.push({ ...handler, id: resolverId });
        router.set(resolverId, {
          ...handler,
          id: resolverId,
          resolver: registered
        });
      }
      socket.send("server:handler:add", configs);
      return new Promise((resolve) => {
        socket.on("server:handler:add", () => {
          socket.remove("server:handler:add");
          resolve();
        });
      });
    },
    resetHandlers(...handlers) {
      const configs = [];
      for (const { resolver } of handlers) {
        if (isRegistered(resolver) && router.has(resolver.__resolverId__)) {
          const resolverId = resolver.__resolverId__;
          const { resolver: _, ...rest } = router.get(resolverId);
          configs.push(rest);
          router.delete(resolverId);
        }
      }
      socket.send("server:handler:remove", configs);
      return new Promise((resolve) => {
        socket.on("server:handler:remove", () => {
          socket.remove("server:handler:remove");
          resolve();
        });
      });
    }
  };
}
function isRegistered(resolver) {
  return typeof resolver === "function" && "__identifier__" in resolver && resolver.__identifier__ === IDENTIFIER && "__resolverId__" in resolver && typeof resolver.__resolverId__ === "string";
}
function registerResolver(resolver) {
  const id = uuid();
  return Object.assign(resolver, {
    get __identifier__() {
      return IDENTIFIER;
    },
    get __resolverId__() {
      return id;
    }
  });
}
function uuid() {
  return crypto.randomBytes(16).toString("hex");
}

export {
  http,
  setupInterceptor
};