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

Features:

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/node.ts
var node_exports = {};
__export(node_exports, {
  createWebRTC: () => createWebRTC
});
module.exports = __toCommonJS(node_exports);
var import_ws = require("ws");

// src/utils.ts
var import_nanoid = require("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 = (0, import_nanoid.nanoid)(6)) {
  const timeStamp = Date.now().toString();
  return `${(0, import_nanoid.nanoid)(6)}-${timeStamp.slice(timeStamp.length - 6, timeStamp.length)}-${(0, import_nanoid.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 import_ws.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 });
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  createWebRTC
});