npm - @webgamekit/multiplayer-p2p - Versions diffs - 0.0.0-stage → 0.1.0 - Mend

@webgamekit/multiplayer-p2p 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/dist/data.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+import type { DataPayload } from 'trystero/nostr';
+import type { P2PSession } from './types';
+/**
+ * Send typed data to all peers on a named channel.
+ * @param session - The active P2P session
+ * @param channel - Channel name (must match receiver's channel name)
+ * @param payload - Serializable data to broadcast
+ */
+export declare const p2pSendData: <T extends DataPayload>(session: P2PSession, channel: string, payload: T) => void;
+/**
+ * Subscribe to typed data arriving on a named channel from any peer.
+ * @param session - The active P2P session
+ * @param channel - Channel name to listen on
+ * @param callback - Called with the payload and the sender's peer ID
+ * @returns Unsubscribe function (stops the listener)
+ */
+export declare const p2pOnData: <T extends DataPayload>(session: P2PSession, channel: string, callback: (payload: T, peerId: string) => void) => (() => void);

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+export type { PlayerPosition, PlayerRotation, PlayerState, PlayerAction, P2PConfig, P2PSession } from './types';
+export { p2pJoin, p2pLeave, p2pOnPeerJoin, p2pOnPeerLeave, p2pIsSupported, p2pGetPeerIds } from './room';
+export { p2pSendPosition, p2pOnPlayers, p2pSendAction, p2pOnAction } from './players';
+export { p2pSendData, p2pOnData } from './data';
+export { p2pMatchmake } from './matchmaker';
+export type { MatchmakeStatus, MatchmakeHandle } from './matchmaker';
+export { p2pLobbyJoin } from './lobby';
+export type { MatchRequest, LobbyCallbacks, LobbyHandle } from './lobby';

package/dist/index.js ADDED Viewed

@@ -0,0 +1,151 @@
+import { joinRoom as h, selfId as k } from "trystero/nostr";
+const M = () => {
+  var t;
+  const e = typeof window < "u" && typeof ((t = window.crypto) == null ? void 0 : t.subtle) < "u";
+  return e || console.warn(
+    `[p2p] crypto.subtle is not available. P2P requires a secure context (HTTPS or localhost). Current origin: ${typeof window < "u" ? window.location.origin : "unknown"}`
+  ), e;
+}, A = (e, t) => {
+  if (!M())
+    throw new Error(
+      `P2P is not supported on this origin (${window.location.origin}). Serve the app over HTTPS or use localhost.`
+    );
+  const o = (t == null ? void 0 : t.appId) ?? "webgamekit", n = h({ appId: o }, e);
+  return {
+    get peerId() {
+      return k;
+    },
+    room: n,
+    destroy: () => {
+      n.leave();
+    }
+  };
+}, R = (e) => Object.keys(e.room.getPeers()), q = (e) => {
+  e.destroy();
+}, S = (e, t) => {
+  e.room.onPeerJoin((o) => {
+    t(o);
+  });
+}, y = (e, t) => {
+  e.room.onPeerLeave((o) => {
+    t(o);
+  });
+}, T = 30, w = /* @__PURE__ */ new WeakMap(), f = /* @__PURE__ */ new WeakMap(), l = /* @__PURE__ */ new WeakMap(), I = /* @__PURE__ */ new WeakMap(), v = (e, t) => {
+  l.has(e) || l.set(e, /* @__PURE__ */ new Map());
+  const o = l.get(e);
+  if (!o.has(t)) {
+    const [n] = e.room.makeAction(t);
+    o.set(t, n);
+  }
+  return o.get(t);
+}, N = (e, t) => {
+  I.has(e) || I.set(e, /* @__PURE__ */ new Set());
+  const o = I.get(e);
+  if (o.has(t)) return null;
+  o.add(t);
+  const [, n] = e.room.makeAction(t);
+  return n;
+}, C = (e, t, o, n) => {
+  const r = (n == null ? void 0 : n.throttleMs) ?? T, c = v(e, "pos"), d = performance.now(), u = f.get(e) ?? 0, m = () => {
+    f.set(e, performance.now()), c({ position: t, rotation: o });
+  };
+  if (d - u >= r) {
+    const a = w.get(e);
+    a !== void 0 && clearTimeout(a), m();
+  } else {
+    const a = w.get(e);
+    a !== void 0 && clearTimeout(a), w.set(
+      e,
+      setTimeout(
+        () => {
+          w.delete(e), m();
+        },
+        r - (d - u)
+      )
+    );
+  }
+}, H = (e, t) => {
+  const o = N(e, "pos");
+  return o && o((n, r) => {
+    const c = n, d = c.position, u = c.rotation;
+    t({ id: r, position: d, rotation: u });
+  }), () => {
+  };
+}, J = (e, t) => {
+  v(e, "action")({ name: t });
+}, x = (e, t) => {
+  const o = N(e, "action");
+  return o && o((n, r) => {
+    t(r, n);
+  }), () => {
+  };
+}, D = (e, t, o) => {
+  const [n] = e.room.makeAction(t);
+  n(o);
+}, W = (e, t, o) => {
+  const [, n] = e.room.makeAction(t);
+  return n((r, c) => o(r, c)), () => {
+  };
+}, _ = (e, t, o) => {
+  const n = A(e, t), r = new Set(R(n)), c = () => {
+    o(r.size > 0 ? "matched" : "searching", r.size);
+  };
+  return S(n, (d) => {
+    r.add(d), c();
+  }), y(n, (d) => {
+    r.delete(d), c();
+  }), c(), {
+    session: n,
+    stop: () => q(n)
+  };
+}, E = "lobby-req", L = "lobby-res", O = "lobby-name", j = (e, t, o) => {
+  const n = A(e, t), [r, c] = n.room.makeAction(E), [d, u] = n.room.makeAction(L), [m, a] = n.room.makeAction(O);
+  let g = "";
+  return S(n, (s) => {
+    g && m({ name: g }, s), o.onPeerJoin(s);
+  }), y(n, o.onPeerLeave), c((s, p) => {
+    o.onRequest(
+      { requestId: s.requestId, gameRoomId: s.gameRoomId },
+      p
+    );
+  }), u((s) => {
+    s.accepted === "true" ? o.onAccepted(s.requestId) : o.onIgnored(s.requestId);
+  }), a((s, p) => {
+    o.onPeerName(p, s.name);
+  }), {
+    session: n,
+    getPeerIds: () => R(n),
+    setName: (s) => {
+      g = s, m({ name: s });
+    },
+    sendRequest: (s, p) => {
+      const i = `${n.peerId}-${Date.now()}`, P = p ?? `${e}-game-${i}`;
+      return r({ requestId: i, gameRoomId: P }, s), { requestId: i, gameRoomId: P };
+    },
+    acceptRequest: (s, p) => {
+      const i = { requestId: s.requestId, accepted: "true" };
+      d(i, p);
+    },
+    ignoreRequest: (s, p) => {
+      const i = { requestId: s.requestId, accepted: "false" };
+      d(i, p);
+    },
+    stop: () => q(n)
+  };
+};
+export {
+  R as p2pGetPeerIds,
+  M as p2pIsSupported,
+  A as p2pJoin,
+  q as p2pLeave,
+  j as p2pLobbyJoin,
+  _ as p2pMatchmake,
+  x as p2pOnAction,
+  W as p2pOnData,
+  S as p2pOnPeerJoin,
+  y as p2pOnPeerLeave,
+  H as p2pOnPlayers,
+  J as p2pSendAction,
+  D as p2pSendData,
+  C as p2pSendPosition
+};

package/dist/index.umd.cjs ADDED Viewed

@@ -0,0 +1 @@

package/dist/lobby.d.ts ADDED Viewed

@@ -0,0 +1,49 @@
+import type { P2PConfig, P2PSession } from './types';
+export interface MatchRequest {
+    requestId: string;
+    gameRoomId: string;
+}
+export interface LobbyCallbacks {
+    /** A new peer appeared in the lobby */
+    onPeerJoin: (peerId: string) => void;
+    /** A peer left the lobby */
+    onPeerLeave: (peerId: string) => void;
+    /** Another peer sent us a match request */
+    onRequest: (request: MatchRequest, fromPeerId: string) => void;
+    /** The peer we requested accepted the match */
+    onAccepted: (requestId: string) => void;
+    /** The peer we requested ignored the match */
+    onIgnored: (requestId: string) => void;
+    /** A peer broadcast their display name */
+    onPeerName: (peerId: string, name: string) => void;
+}
+export interface LobbyHandle {
+    session: P2PSession;
+    /** IDs of all peers currently in the lobby */
+    getPeerIds: () => string[];
+    /** Broadcast a display name to all current peers and auto-send it to future joiners */
+    setName: (name: string) => void;
+    /**
+     * Send a match request to a specific peer — returns the request for tracking.
+     * Pass `gameRoomId` to advertise the caller's existing room; omit to auto-generate one.
+     */
+    sendRequest: (targetPeerId: string, gameRoomId?: string) => MatchRequest;
+    /** Accept an incoming match request */
+    acceptRequest: (request: MatchRequest, fromPeerId: string) => void;
+    /** Ignore an incoming match request */
+    ignoreRequest: (request: MatchRequest, fromPeerId: string) => void;
+    /** Leave the lobby and clean up */
+    stop: () => void;
+}
+/**
+ * Join a lobby room for peer discovery and match negotiation.
+ *
+ * Peers in the lobby can broadcast a display name, send targeted match
+ * requests to each other, and accept or ignore each request individually.
+ * On acceptance, both sides receive the shared `gameRoomId` to join.
+ * @param lobbyRoomId - Well-known room ID all players join to discover each other
+ * @param config - Optional P2P configuration
+ * @param callbacks - Event handlers for peer, name, and request lifecycle events
+ * @returns A handle to set a name, send requests, respond, and leave the lobby
+ */
+export declare const p2pLobbyJoin: (lobbyRoomId: string, config: P2PConfig | undefined, callbacks: LobbyCallbacks) => LobbyHandle;

package/dist/matchmaker.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import type { P2PConfig, P2PSession } from './types';
+export type MatchmakeStatus = 'searching' | 'matched';
+export interface MatchmakeHandle {
+    /** The underlying P2P session — use this to send/receive game data */
+    session: P2PSession;
+    /** Leave the room and stop matchmaking */
+    stop: () => void;
+}
+/**
+ * Join a shared room and report status changes as peers arrive or leave.
+ *
+ * - Calls `onStatusChange('searching', 0)` immediately if no peers are present.
+ * - Calls `onStatusChange('matched', n)` whenever peer count rises above zero.
+ * - Reverts to `'searching'` if all peers disconnect.
+ * @param roomId - Shared room to join (same value for all players in the session)
+ * @param config - Optional P2P configuration
+ * @param onStatusChange - Fired on initial join and on every peer join/leave
+ * @returns A handle with the active session and a `stop()` function to leave
+ */
+export declare const p2pMatchmake: (roomId: string, config: P2PConfig | undefined, onStatusChange: (status: MatchmakeStatus, peerCount: number) => void) => MatchmakeHandle;

package/dist/players.d.ts ADDED Viewed

@@ -0,0 +1,29 @@
+import type { PlayerPosition, PlayerRotation, PlayerState, PlayerAction, P2PConfig, P2PSession } from './types';
+/**
+ * Broadcast the local player's position and rotation to all peers, throttled.
+ * @param session - The active P2P session
+ * @param position - Current player position {x, y, z}
+ * @param rotation - Current player rotation {x, y, z}
+ * @param config - Optional config carrying throttleMs
+ */
+export declare const p2pSendPosition: (session: P2PSession, position: PlayerPosition, rotation: PlayerRotation, config?: P2PConfig) => void;
+/**
+ * Subscribe to position updates from other peers.
+ * @param session - The active P2P session
+ * @param callback - Called with the sender's PlayerState on each update
+ * @returns Unsubscribe function
+ */
+export declare const p2pOnPlayers: (session: P2PSession, callback: (player: PlayerState) => void) => (() => void);
+/**
+ * Broadcast a named animation action to all peers.
+ * @param session - The active P2P session
+ * @param actionName - Animation clip name to play (e.g. "wave", "attack")
+ */
+export declare const p2pSendAction: (session: P2PSession, actionName: string) => void;
+/**
+ * Subscribe to animation action broadcasts from other peers.
+ * @param session - The active P2P session
+ * @param callback - Called with the sender's peer ID and action name
+ * @returns Unsubscribe function
+ */
+export declare const p2pOnAction: (session: P2PSession, callback: (peerId: string, action: PlayerAction) => void) => (() => void);

package/dist/room.d.ts ADDED Viewed

@@ -0,0 +1,39 @@
+import type { P2PConfig, P2PSession } from './types';
+/**
+ * Check whether the browser exposes crypto.subtle (requires HTTPS or localhost).
+ * @returns true if the environment supports P2P
+ */
+export declare const p2pIsSupported: () => boolean;
+/**
+ * Join a P2P room using WebRTC via Trystero (torrent signaling — no server required).
+ * All peers in the same roomId can communicate directly.
+ * Requires a secure context (HTTPS or localhost) — throws if crypto.subtle is unavailable.
+ * @param roomId - Shared identifier for the game room (e.g. "level-1-abc123")
+ * @param config - Optional configuration overrides
+ * @returns A P2PSession with the room handle and destroy function
+ */
+export declare const p2pJoin: (roomId: string, config?: P2PConfig) => P2PSession;
+/**
+ * Return the IDs of all peers currently connected in the room.
+ * Use this immediately after joining to catch peers that joined before you.
+ * @param session - The active P2P session
+ * @returns Array of peer IDs already in the room
+ */
+export declare const p2pGetPeerIds: (session: P2PSession) => string[];
+/**
+ * Leave a P2P room and clean up all connections.
+ * @param session - The session returned by p2pJoin
+ */
+export declare const p2pLeave: (session: P2PSession) => void;
+/**
+ * Subscribe to a callback fired when a remote peer joins the room.
+ * @param session - The active P2P session
+ * @param callback - Called with the peer's ID when they join
+ */
+export declare const p2pOnPeerJoin: (session: P2PSession, callback: (peerId: string) => void) => void;
+/**
+ * Subscribe to a callback fired when a remote peer leaves the room.
+ * @param session - The active P2P session
+ * @param callback - Called with the peer's ID when they leave
+ */
+export declare const p2pOnPeerLeave: (session: P2PSession, callback: (peerId: string) => void) => void;

package/dist/types.d.ts ADDED Viewed

@@ -0,0 +1,37 @@
+import type { Room, DataPayload } from 'trystero/nostr';
+export type { DataPayload };
+export interface P2PConfig {
+    /** App identifier — must be unique to your game (default: "webgamekit") */
+    appId?: string;
+    /** Minimum ms between position broadcasts (default: 30) */
+    throttleMs?: number;
+}
+export interface P2PSession {
+    /** Local peer ID assigned by Trystero */
+    peerId: string;
+    /** The underlying Trystero Room */
+    room: Room;
+    /** Leave the room and clean up */
+    destroy: () => void;
+}
+/** Serializable position — compatible with Trystero DataPayload */
+export type PlayerPosition = {
+    x: number;
+    y: number;
+    z: number;
+} & Record<string, number>;
+/** Serializable rotation — compatible with Trystero DataPayload */
+export type PlayerRotation = {
+    x: number;
+    y: number;
+    z: number;
+} & Record<string, number>;
+export interface PlayerState {
+    id: string;
+    position: PlayerPosition;
+    rotation: PlayerRotation;
+}
+/** Serializable animation action — compatible with Trystero DataPayload */
+export type PlayerAction = {
+    name: string;
+} & Record<string, string>;

package/package.json CHANGED Viewed

@@ -1,6 +1,38 @@
 {
   "name": "@webgamekit/multiplayer-p2p",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cnotv/generative-art.git",
+    "directory": "packages/multiplayer-p2p"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.umd.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.umd.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "trystero": "^0.23.0"
+  },
+  "devDependencies": {
+    "trystero": "^0.23.0",
+    "typescript": "^5.0.0",
+    "vite": "^5.0.0",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "vite build && tsc"
+  }
 }

package/README.md DELETED Viewed

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.