@lzpenguin/server 1.0.0 → 1.0.2

package/index.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Riffle 游戏服务器 WebSocket 客户端 SDK
+ */
+
+/**
+ * RiffleServer 构造函数选项
+ */
+export interface RiffleServerOptions {
+  /** WebSocket 服务器 URL */
+  url: string;
+  /** 游戏贴文 ID */
+  postId: number;
+  /** 认证 token */
+  token: string;
+  /** 是否自动重连，默认 true */
+  autoReconnect?: boolean;
+  /** 重连间隔（毫秒），默认 3000 */
+  reconnectInterval?: number;
+}
+
+/**
+ * 玩家数据
+ */
+export interface PlayerSelfData {
+  /** 公开数据 */
+  public?: Record<string, any>;
+  /** 私有数据 */
+  private?: Record<string, any>;
+}
+
+/**
+ * 初始化数据
+ */
+export interface InitData {
+  /** 游戏版本哈希值（必需） */
+  hash: string;
+  /** 世界初始数据（可选） */
+  world?: Record<string, any>;
+  /** 玩家初始数据（可选） */
+  self?: PlayerSelfData;
+}
+
+/**
+ * 更新数据
+ */
+export interface UpdateData {
+  /** 世界数据（可选，部分更新） */
+  world?: Record<string, any>;
+  /** 玩家数据（可选，部分更新） */
+  self?: PlayerSelfData;
+}
+
+/**
+ * 服务器推送的数据
+ */
+export interface ServerData {
+  /** 世界数据 */
+  world: Record<string, any>;
+  /** 当前玩家数据 */
+  self: PlayerSelfData;
+  /** 其他玩家列表（仅公开数据） */
+  players: Array<Record<string, any>>;
+}
+
+/**
+ * RiffleServer - 游戏服务器 WebSocket 客户端
+ */
+export class RiffleServer {
+  /**
+   * 创建 RiffleServer 实例
+   * @param options 配置选项
+   */
+  constructor(options: RiffleServerOptions);
+
+  /** 是否已连接 */
+  readonly isConnected: boolean;
+  /** 是否正在连接 */
+  readonly isConnecting: boolean;
+  /** 是否已初始化 */
+  readonly isInitialized: boolean;
+
+  /**
+   * 初始化服务器（必需，连接后必须先调用）
+   * @param initData 初始化数据
+   */
+  init(initData: InitData): void;
+
+  /**
+   * 更新数据（部分更新，合并到现有数据）
+   * @param updateData 更新数据
+   */
+  update(updateData: UpdateData): void;
+
+  /**
+   * 监听服务器推送的最新数据
+   * @param callback 回调函数，接收服务器推送的数据
+   * @returns 取消监听的函数
+   */
+  onData(callback: (data: ServerData) => void): () => void;
+}
+

package/index.js

@@ -1,4 +1,32 @@
-import WebSocket from 'ws';
+// 检测运行环境，浏览器使用原生 WebSocket，Node.js 使用 ws 库
+let WebSocketImpl;
+let isBrowser = false;
+
+if (typeof window !== 'undefined' && window.WebSocket) {
+  // 浏览器环境
+  WebSocketImpl = window.WebSocket;
+  isBrowser = true;
+} else {
+  // Node.js 环境 - 使用动态导入
+  try {
+    // 使用 require 或 import，根据环境选择
+    if (typeof require !== 'undefined') {
+      // CommonJS 环境
+      WebSocketImpl = require('ws');
+    } else {
+      // ES Module 环境 - 在运行时动态导入
+      // 注意：这需要在异步上下文中使用
+      WebSocketImpl = null; // 将在 connect 方法中动态导入
+    }
+  } catch (e) {
+    // 如果无法导入 ws，尝试使用全局 WebSocket（某些打包工具可能会提供）
+    if (typeof WebSocket !== 'undefined') {
+      WebSocketImpl = WebSocket;
+    } else {
+      throw new Error('WebSocket is not available. In Node.js, please install "ws" package.');
+    }
+  }
+}
 
 /**
  * RiffleServer - 游戏服务器 WebSocket 客户端
@@ -79,29 +107,43 @@ export class RiffleServer {
     // 当前服务器数据缓存
     this.currentData = null;
 
-    // 连接状态
-    this.connect();
+    // 连接状态（异步调用，不阻塞构造函数）
+    this.connect().catch(err => {
+      console.error('[RiffleServer] Initial connection failed:', err);
+    });
   }
 
   /**
    * 连接到 WebSocket 服务器
    * @private
    */
-  connect() {
-    if (this.isConnecting || (this.isConnected && this.ws?.readyState === WebSocket.OPEN)) {
+  async connect() {
+    if (this.isConnecting || (this.isConnected && this.ws?.readyState === (WebSocketImpl?.OPEN ?? 1))) {
       return;
     }
 
     this.isConnecting = true;
 
+    // 如果在 Node.js 环境且 WebSocketImpl 未初始化，动态导入
+    if (!isBrowser && !WebSocketImpl) {
+      try {
+        const wsModule = await import('ws');
+        WebSocketImpl = wsModule.default;
+      } catch (e) {
+        this.isConnecting = false;
+        console.error('[RiffleServer] Failed to import ws module:', e);
+        throw new Error('WebSocket is not available. In Node.js, please install "ws" package.');
+      }
+    }
+
     // 构建 WebSocket URL（包含 post_id 和 token）
     let wsUrl = `${this.url}?post_id=${this.postId}&token=${this.token}`;
 
-
     try {
-      this.ws = new WebSocket(wsUrl);
+      this.ws = new WebSocketImpl(wsUrl);
 
-      this.ws.on('open', () => {
+      // 统一事件处理：浏览器用 addEventListener，Node.js 用 .on()
+      const handleOpen = () => {
         this.isConnected = true;
         this.isConnecting = false;
         this.isInitialized = false;  // 连接后重置初始化状态
@@ -113,11 +155,13 @@ export class RiffleServer {
           this.pendingInit = null;
           this._doInit(initData);
         }
-      });
+      };
 
-      this.ws.on('message', (data) => {
+      const handleMessage = (event) => {
         try {
-          const message = JSON.parse(data.toString());
+          // 浏览器: event.data, Node.js: event (Buffer 或 string)
+          const data = event.data || event;
+          const message = JSON.parse(typeof data === 'string' ? data : data.toString());
           
           // 检查是否是错误消息
           if (message.error) {
@@ -140,13 +184,13 @@ export class RiffleServer {
         } catch (error) {
           console.error('[RiffleServer] Failed to parse message:', error);
         }
-      });
+      };
 
-      this.ws.on('error', (error) => {
+      const handleError = (error) => {
         console.error('[RiffleServer] WebSocket error:', error);
-      });
+      };
 
-      this.ws.on('close', () => {
+      const handleClose = () => {
         this.isConnected = false;
         this.isConnecting = false;
         this.isInitialized = false;  // 断开连接后重置初始化状态
@@ -159,7 +203,20 @@ export class RiffleServer {
             this.connect();
           }, this.reconnectInterval);
         }
-      });
+      };
+
+      // 根据环境使用不同的事件绑定方式
+      if (isBrowser) {
+        this.ws.addEventListener('open', handleOpen);
+        this.ws.addEventListener('message', handleMessage);
+        this.ws.addEventListener('error', handleError);
+        this.ws.addEventListener('close', handleClose);
+      } else {
+        this.ws.on('open', handleOpen);
+        this.ws.on('message', handleMessage);
+        this.ws.on('error', handleError);
+        this.ws.on('close', handleClose);
+      }
     } catch (error) {
       this.isConnecting = false;
       console.error('[RiffleServer] Connection error:', error);
@@ -189,7 +246,7 @@ export class RiffleServer {
    * @param {Object} updateData - 更新数据
    */
   sendUpdate(updateData) {
-    if (!this.isConnected || this.ws?.readyState !== WebSocket.OPEN) {
+    if (!this.isConnected || this.ws?.readyState !== WebSocketImpl.OPEN) {
       console.warn('[RiffleServer] Not connected, cannot send update');
       return;
     }
@@ -231,7 +288,7 @@ export class RiffleServer {
     }
 
     // 如果还未连接，保存 init 请求，连接建立后自动执行
-    if (!this.isConnected || this.ws?.readyState !== WebSocket.OPEN) {
+    if (!this.isConnected || this.ws?.readyState !== WebSocketImpl.OPEN) {
       console.log('[RiffleServer] Not connected yet, will init after connection');
       this.pendingInit = initData;
       return;

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "@lzpenguin/server",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Riffle 游戏服务器 WebSocket 客户端 SDK",
   "license": "ISC",
   "author": "lzpenguin",
   "type": "module",
   "main": "./index.js",
+  "types": "./index.d.ts",
   "exports": {
     ".": {
-      "import": "./index.js"
+      "import": "./index.js",
+      "types": "./index.d.ts"
     }
   },
   "files": [
     "index.js",
+    "index.d.ts",
     "README.md"
   ],
   "keywords": [
@@ -34,4 +37,3 @@
     "registry": "https://registry.npmjs.org/"
   }
 }
-