dignity.js 0.5.2 → 0.5.3

package/docs/chess/src/lib/localGames.js

@@ -1,160 +0,0 @@
-const SESSIONS_KEY = 'dignity-chess-sessions';
-const COLLECTION = 'chess-matches';
-const DB_NAME = 'dignity';
-const STORE_NAME = 'records';
-
-export function loadLocalGameSessions() {
-  try {
-    const raw = localStorage.getItem(SESSIONS_KEY);
-    const parsed = raw ? JSON.parse(raw) : [];
-    return Array.isArray(parsed) ? parsed : [];
-  } catch (error) {
-    return [];
-  }
-}
-
-export function saveLocalGameSession(session) {
-  if (!session?.gameId || !session?.roomKey) {
-    return;
-  }
-
-  const sessions = loadLocalGameSessions();
-  const index = sessions.findIndex((entry) => entry.gameId === session.gameId);
-  const next = {
-    ...sessions[index],
-    ...session,
-    updatedAt: session.updatedAt || Date.now()
-  };
-
-  if (index >= 0) {
-    sessions[index] = next;
-  } else {
-    sessions.unshift(next);
-  }
-
-  const trimmed = sessions
-    .sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0))
-    .slice(0, 40);
-
-  localStorage.setItem(SESSIONS_KEY, JSON.stringify(trimmed));
-}
-
-function loadChessRecordsFromIndexedDB() {
-  if (typeof indexedDB === 'undefined') {
-    return Promise.resolve([]);
-  }
-
-  return new Promise((resolve) => {
-    const request = indexedDB.open(DB_NAME, 1);
-
-    request.onerror = () => resolve([]);
-    request.onsuccess = () => {
-      const db = request.result;
-      if (!db.objectStoreNames.contains(STORE_NAME)) {
-        db.close();
-        resolve([]);
-        return;
-      }
-
-      const transaction = db.transaction(STORE_NAME, 'readonly');
-      const store = transaction.objectStore(STORE_NAME);
-      const getAll = store.getAll();
-
-      getAll.onsuccess = () => {
-        const records = (getAll.result || []).filter(
-          (record) => record.collection === COLLECTION && !record.deletedAt
-        );
-        resolve(records);
-        db.close();
-      };
-
-      getAll.onerror = () => {
-        resolve([]);
-        db.close();
-      };
-    };
-  });
-}
-
-function mergeSessionWithRecord(session, record) {
-  if (!record?.data) {
-    return session;
-  }
-
-  return {
-    ...session,
-    status: record.data.status || session.status || 'waiting',
-    winner: record.data.winner ?? session.winner ?? null,
-    moveCount: Array.isArray(record.data.moveHistory) ? record.data.moveHistory.length : session.moveCount || 0,
-    whitePlayerId: record.data.whitePlayerId || session.whitePlayerId || null,
-    blackPlayerId: record.data.blackPlayerId || session.blackPlayerId || null,
-    updatedAt: record.updatedAt || session.updatedAt || Date.now()
-  };
-}
-
-export async function listLocalGames() {
-  const sessions = loadLocalGameSessions();
-  const records = await loadChessRecordsFromIndexedDB();
-  const recordById = new Map(records.map((record) => [record.id, record]));
-
-  const merged = sessions.map((session) => mergeSessionWithRecord(session, recordById.get(session.gameId)));
-
-  const active = merged.filter((game) => game.status === 'waiting' || game.status === 'playing');
-  const finished = merged.filter((game) => game.status === 'finished');
-
-  return { active, finished };
-}
-
-export function sessionResumeHash(session) {
-  const role = session.role === 'host' ? 'host' : 'resume';
-  const params = new URLSearchParams({
-    game: session.gameId,
-    room: session.roomKey,
-    role,
-    resume: session.resumeToken || ''
-  });
-
-  if (session.hostPeer) {
-    params.set('host', session.hostPeer);
-  }
-  if (session.role === 'host' && session.joinToken) {
-    params.set('join', session.joinToken);
-  }
-  if (session.role === 'host' && session.watchToken) {
-    params.set('watch', session.watchToken);
-  }
-
-  return params.toString();
-}
-
-export function formatGameStatus(game) {
-  if (game.status === 'waiting') {
-    return 'Waiting for opponent';
-  }
-  if (game.status === 'playing') {
-    return `${game.moveCount || 0} move(s) · in progress`;
-  }
-  if (game.winner === 'draw') {
-    return 'Draw';
-  }
-  if (game.winner === 'w') {
-    return 'White wins';
-  }
-  if (game.winner === 'b') {
-    return 'Black wins';
-  }
-  return 'Finished';
-}
-
-export function formatRoleLabel(game) {
-  if (game.role === 'host') {
-    return 'You · White (host)';
-  }
-  if (game.role === 'join') {
-    return 'You · Black';
-  }
-  if (game.role === 'watch') {
-    return 'Spectator';
-  }
-  return 'Resume';
-}

package/docs/chess/src/lib/p2pDebug.js

@@ -1,192 +0,0 @@
-const PREFIX = '[chess-p2p]';
-
-function ts() {
-  return new Date().toISOString().slice(11, 23);
-}
-
-export function p2pLog(label, detail) {
-  if (detail === undefined) {
-    console.log(`${PREFIX} ${ts()} ${label}`);
-    return;
-  }
-  console.log(`${PREFIX} ${ts()} ${label}`, detail);
-}
-
-export function p2pWarn(label, detail) {
-  if (detail === undefined) {
-    console.warn(`${PREFIX} ${ts()} ${label}`);
-    return;
-  }
-  console.warn(`${PREFIX} ${ts()} ${label}`, detail);
-}
-
-export function p2pError(label, detail) {
-  if (detail === undefined) {
-    console.error(`${PREFIX} ${ts()} ${label}`);
-    return;
-  }
-  console.error(`${PREFIX} ${ts()} ${label}`, detail);
-}
-
-export function connectionSnapshot(node) {
-  const adapter = node?.networkAdapter;
-  if (!adapter) {
-    return { adapter: 'none' };
-  }
-
-  const openIds = [];
-  if (adapter.connections instanceof Map) {
-    for (const [peerId, conn] of adapter.connections.entries()) {
-      if (conn?.open) {
-        openIds.push(peerId);
-      }
-    }
-  }
-
-  return {
-    signalingUrl: adapter.url || null,
-    localPeerId: adapter.nodeId || node?.nodeId || null,
-    openConnectionCount: node?.getConnectionStats?.()?.openCount ?? adapter.getOpenConnectionCount?.() ?? openIds.length,
-    openPeerIds: node?.getConnectionStats?.()?.peerIds ?? openIds,
-    peerJsReady: Boolean(adapter.peer)
-  };
-}
-
-export function attachNodeDebugListeners(node, context = {}) {
-  if (!node || node.__chessDebugAttached) {
-    return () => undefined;
-  }
-
-  node.__chessDebugAttached = true;
-  const role = context.role || '?';
-
-  p2pLog(`debug attached (${role})`, {
-    nodeId: node.nodeId,
-    scope: context.scope,
-    gameId: context.gameId
-  });
-
-  const handlers = {
-    warning: (event) => p2pWarn('node warning', event),
-    securityerror: (event) => p2pError('security error', {
-      senderId: event?.senderId,
-      code: event?.error?.code,
-      message: event?.error?.message
-    }),
-    messageignored: (event) => p2pWarn('message ignored', event),
-    peerdiscovered: (event) => p2pLog('peer discovered', event),
-    peerleft: (event) => p2pLog('peer left', event),
-    peerbanned: (event) => p2pError('peer banned', event),
-    conflict: (event) => p2pWarn('sync conflict', event),
-    change: (event) => {
-      if (event?.collection === context.collection) {
-        p2pLog('game record changed', {
-          id: event.id,
-          kind: event.kind,
-          version: event.version
-        });
-      }
-    },
-    message: (event) => {
-      if (event?.type === 'claim-seat' || event?.type === 'operation') {
-        p2pLog('incoming message', {
-          type: event.type,
-          senderId: event.senderId,
-          payload: event.payload
-        });
-      }
-    }
-  };
-
-  for (const [eventName, handler] of Object.entries(handlers)) {
-    node.on(eventName, handler);
-  }
-
-  if (node.networkAdapter?.peer) {
-    const peer = node.networkAdapter.peer;
-    peer.on('error', (err) => {
-      p2pError('PeerJS error', {
-        type: err?.type,
-        message: err?.message || String(err)
-      });
-    });
-    peer.on('disconnected', () => p2pWarn('PeerJS disconnected from signaling server'));
-    peer.on('close', () => p2pWarn('PeerJS peer closed'));
-    peer.on('connection', (conn) => {
-      p2pLog('PeerJS inbound connection', { from: conn.peer });
-      conn.on('open', () => p2pLog('PeerJS data channel open (inbound)', { peer: conn.peer }));
-      conn.on('close', () => p2pWarn('PeerJS data channel closed (inbound)', { peer: conn.peer }));
-      conn.on('error', (err) => p2pError('PeerJS data channel error (inbound)', {
-        peer: conn.peer,
-        message: err?.message || String(err)
-      }));
-    });
-  }
-
-  return () => {
-    for (const [eventName, handler] of Object.entries(handlers)) {
-      node.off(eventName, handler);
-    }
-    delete node.__chessDebugAttached;
-  };
-}
-
-export function dumpJoinState({
-  route,
-  node,
-  nodeId,
-  scope,
-  status,
-  error,
-  joined,
-  roomConnected,
-  connectionCount,
-  remoteHostPeer,
-  peers,
-  game,
-  myColor
-}) {
-  const snap = connectionSnapshot(node);
-  const payload = {
-    role: route.role,
-    localNodeId: nodeId,
-    nodeRunningId: node?.nodeId,
-    hostPeerTarget: remoteHostPeer,
-    routeHostParam: route.hostPeer,
-    gameId: route.gameId,
-    scope,
-    dignityStatus: status,
-    dignityError: error?.message || null,
-    joinedDiscovery: joined,
-    roomConnected,
-    connectionCount,
-    peerJs: snap,
-    peers: peers.map((p) => ({
-      peerId: p.peerId,
-      role: p.metadata?.role,
-      nickname: p.metadata?.nickname,
-      joinToken: p.metadata?.joinToken ? `${p.metadata.joinToken.slice(0, 6)}…` : null
-    })),
-    game: game ? {
-      status: game.data?.status,
-      whitePlayerId: game.data?.whitePlayerId,
-      blackPlayerId: game.data?.blackPlayerId,
-      joinTokenUsed: game.data?.joinTokenUsed,
-      joinTokenMatch: route.joinToken === game.data?.joinToken,
-      version: game.version
-    } : null,
-    myColor,
-    webrtc: typeof RTCPeerConnection !== 'undefined' ? 'available' : 'missing'
-  };
-
-  p2pLog('STATE SNAPSHOT', payload);
-  return payload;
-}
-
-export function installGlobalDebug(dumpFn) {
-  if (typeof window === 'undefined') {
-    return;
-  }
-  window.__chessP2pDump = dumpFn;
-  p2pLog('manual dump: run __chessP2pDump() in console');
-}

package/docs/chess/src/main.jsx

@@ -1,5 +0,0 @@
-import React from 'react';
-import { createRoot } from 'react-dom/client';
-import App from './App.jsx';
-
-createRoot(document.getElementById('root')).render(<App />);