@oiij/web-rtc/dist/node.js

Features:

// src/node.ts
import { WebSocketServer } from "ws";

// src/utils.ts
import { nanoid } from "nanoid";
function createDebug(debug) {
  return function(msg, type) {
    if (!debug)
      return;
    switch (type) {
      case "info":
        return console.info(msg);
      case "error":
        return console.error(msg);
      default:
        return console.log(msg);
    }
  };
}
function createId(str = nanoid(6)) {
  const timeStamp = Date.now().toString();
  return `${nanoid(6)}-${timeStamp.slice(timeStamp.length - 6, timeStamp.length)}-${nanoid(6)}-${str.slice(0, 6)}`;
}

// src/node.ts
function sendMessage(socket, data) {
  socket.send(JSON.stringify(data));
}
function createWebRTC(options) {
  const { host = "127.0.0.1", port = 6789, path = "/_web-rtc", debug = false } = options ?? {};
  const socketMap = /* @__PURE__ */ new Map();
  const debugLog = createDebug(debug);
  const server = new WebSocketServer({
    port,
    path
  }, () => {
    debugLog(`web-rtc server start at http://${host}:${port}${path}`);
  });
  function getSocket(key) {
    return key ? socketMap.get(key) : void 0;
  }
  server.on("connection", (socket, request) => {
    const key = createId(request.headers["sec-websocket-key"]);
    if (!key) {
      debugLog("sec-websocket-key not found");
      return;
    }
    if (!socketMap.has(key)) {
      socketMap.set(key, socket);
    }
    sendMessage(socket, {
      type: "register",
      payload: {
        key
      }
    });
    debugLog(`socket connect ${key}`);
    socket.on("message", (dataRaw) => {
      try {
        const { type, payload } = JSON.parse(dataRaw.toString());
        const { key: targetKey, desc, candidate } = payload;
        switch (type) {
          case "offer":
            {
              const target = getSocket(targetKey);
              if (!target) {
                debugLog(`offer target not found ${targetKey}`);
                return;
              }
              sendMessage(target, {
                type: "offer",
                payload: {
                  key,
                  desc
                }
              });
            }
            break;
          case "answer":
            {
              const target = getSocket(targetKey);
              if (!target) {
                debugLog(`answer targetIns not found ${targetKey}`);
                return;
              }
              sendMessage(target, {
                type: "answer",
                payload: {
                  key: targetKey,
                  desc
                }
              });
            }
            break;
          case "answer-ok":
            {
              const target = getSocket(targetKey);
              if (!target) {
                debugLog(`answer-ok targetIns not found ${targetKey}`);
                return;
              }
              sendMessage(target, {
                type: "answer-ok",
                payload: {
                  key
                }
              });
            }
            break;
          case "ice-candidate":
            socketMap.entries().forEach(([_key, _socket]) => {
              if (_key === key)
                return;
              sendMessage(_socket, {
                type: "ice-candidate",
                payload: {
                  key,
                  candidate
                }
              });
            });
            break;
          default:
            break;
        }
      } catch (error) {
        debugLog(error.toString(), "error");
      }
    });
    socket.on("close", () => {
      debugLog("socket close");
    });
  });
  server.on("error", (err) => {
    debugLog(err.message, "error");
  });
}
createWebRTC({ debug: true });
export {
  createWebRTC
};