@lark-sh/client 0.1.3 → 0.1.4

package/dist/index.d.mts

@@ -283,6 +283,7 @@ declare class LarkDatabase {
     private _auth;
     private _databaseId;
     private _coordinatorUrl;
+    private _volatilePaths;
     private ws;
     private messageQueue;
     private subscriptionManager;
@@ -302,6 +303,12 @@ declare class LarkDatabase {
      * @internal Get the base URL for reference toString().
      */
     _getBaseUrl(): string;
+    /**
+     * Get the volatile path patterns from the server.
+     * These patterns indicate which paths should use unreliable transport.
+     * WebSocket always uses reliable transport, but this is stored for future UDP support.
+     */
+    get volatilePaths(): string[];
     /**
      * Connect to a database.
      *
@@ -424,4 +431,24 @@ declare class LarkError extends Error {
  */
 declare function generatePushId(): string;
 
-export { type AuthInfo, type ConnectOptions, DataSnapshot, DatabaseReference, type EventType, LarkDatabase, LarkError, OnDisconnect, type QueryState, type SnapshotCallback$1 as SnapshotCallback, generatePushId };
+/**
+ * Volatile path matching utilities.
+ *
+ * Volatile paths are patterns where a wildcard matches exactly one path segment.
+ * These paths use unreliable transport for better performance (UDP when available).
+ */
+/**
+ * Check if a path matches any of the volatile path patterns.
+ *
+ * Pattern matching rules:
+ * - Wildcard matches exactly one path segment (not zero, not multiple)
+ * - Patterns and paths are compared segment by segment
+ * - Path must have the same number of segments as the pattern
+ *
+ * @param path - The path to check (e.g., "/players/abc/position")
+ * @param patterns - Array of volatile patterns with wildcards
+ * @returns true if the path matches any pattern
+ */
+declare function isVolatilePath(path: string, patterns: string[] | null | undefined): boolean;
+
+export { type AuthInfo, type ConnectOptions, DataSnapshot, DatabaseReference, type EventType, LarkDatabase, LarkError, OnDisconnect, type QueryState, type SnapshotCallback$1 as SnapshotCallback, generatePushId, isVolatilePath };

package/dist/index.d.ts

@@ -283,6 +283,7 @@ declare class LarkDatabase {
     private _auth;
     private _databaseId;
     private _coordinatorUrl;
+    private _volatilePaths;
     private ws;
     private messageQueue;
     private subscriptionManager;
@@ -302,6 +303,12 @@ declare class LarkDatabase {
      * @internal Get the base URL for reference toString().
      */
     _getBaseUrl(): string;
+    /**
+     * Get the volatile path patterns from the server.
+     * These patterns indicate which paths should use unreliable transport.
+     * WebSocket always uses reliable transport, but this is stored for future UDP support.
+     */
+    get volatilePaths(): string[];
     /**
      * Connect to a database.
      *
@@ -424,4 +431,24 @@ declare class LarkError extends Error {
  */
 declare function generatePushId(): string;
 
-export { type AuthInfo, type ConnectOptions, DataSnapshot, DatabaseReference, type EventType, LarkDatabase, LarkError, OnDisconnect, type QueryState, type SnapshotCallback$1 as SnapshotCallback, generatePushId };
+/**
+ * Volatile path matching utilities.
+ *
+ * Volatile paths are patterns where a wildcard matches exactly one path segment.
+ * These paths use unreliable transport for better performance (UDP when available).
+ */
+/**
+ * Check if a path matches any of the volatile path patterns.
+ *
+ * Pattern matching rules:
+ * - Wildcard matches exactly one path segment (not zero, not multiple)
+ * - Patterns and paths are compared segment by segment
+ * - Path must have the same number of segments as the pattern
+ *
+ * @param path - The path to check (e.g., "/players/abc/position")
+ * @param patterns - Array of volatile patterns with wildcards
+ * @returns true if the path matches any pattern
+ */
+declare function isVolatilePath(path: string, patterns: string[] | null | undefined): boolean;
+
+export { type AuthInfo, type ConnectOptions, DataSnapshot, DatabaseReference, type EventType, LarkDatabase, LarkError, OnDisconnect, type QueryState, type SnapshotCallback$1 as SnapshotCallback, generatePushId, isVolatilePath };

package/dist/index.js

@@ -35,7 +35,8 @@ __export(index_exports, {
   LarkDatabase: () => LarkDatabase,
   LarkError: () => LarkError,
   OnDisconnect: () => OnDisconnect,
-  generatePushId: () => generatePushId
+  generatePushId: () => generatePushId,
+  isVolatilePath: () => isVolatilePath
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -119,10 +120,10 @@ var LarkError = class _LarkError extends Error {
 
 // src/protocol/messages.ts
 function isAckMessage(msg) {
-  return "a" in msg && !("uid" in msg);
+  return "a" in msg;
 }
-function isJoinAckMessage(msg) {
-  return "a" in msg && "uid" in msg;
+function isJoinCompleteMessage(msg) {
+  return "jc" in msg;
 }
 function isNackMessage(msg) {
   return "n" in msg;
@@ -178,16 +179,12 @@ var MessageQueue = class {
    * @returns true if the message was handled (was a response), false otherwise
    */
   handleMessage(message) {
-    if (isJoinAckMessage(message)) {
-      const pending = this.pending.get(message.a);
+    if (isJoinCompleteMessage(message)) {
+      const pending = this.pending.get(message.jc);
       if (pending) {
         clearTimeout(pending.timeout);
-        this.pending.delete(message.a);
-        pending.resolve({
-          uid: message.uid,
-          provider: message.provider,
-          token: message.token
-        });
+        this.pending.delete(message.jc);
+        pending.resolve(message.vp || []);
         return true;
       }
     }
@@ -1279,6 +1276,7 @@ var LarkDatabase = class {
     this._auth = null;
     this._databaseId = null;
     this._coordinatorUrl = null;
+    this._volatilePaths = [];
     this.ws = null;
     // Event callbacks
     this.connectCallbacks = /* @__PURE__ */ new Set();
@@ -1311,6 +1309,14 @@ var LarkDatabase = class {
     }
     return "lark://";
   }
+  /**
+   * Get the volatile path patterns from the server.
+   * These patterns indicate which paths should use unreliable transport.
+   * WebSocket always uses reliable transport, but this is stored for future UDP support.
+   */
+  get volatilePaths() {
+    return this._volatilePaths;
+  }
   // ============================================
   // Connection Management
   // ============================================
@@ -1351,7 +1357,8 @@ var LarkDatabase = class {
         r: requestId
       };
       this.send(joinMessage);
-      await this.messageQueue.registerRequest(requestId);
+      const volatilePaths = await this.messageQueue.registerRequest(requestId);
+      this._volatilePaths = volatilePaths || [];
       const jwtPayload = decodeJwtPayload(connectResponse.token);
       this._auth = {
         uid: jwtPayload.sub,
@@ -1404,6 +1411,7 @@ var LarkDatabase = class {
     this._state = "disconnected";
     this._auth = null;
     this._databaseId = null;
+    this._volatilePaths = [];
     this._coordinatorUrl = null;
     this.subscriptionManager.clear();
     this.messageQueue.rejectAll(new Error("Connection closed"));
@@ -1653,6 +1661,21 @@ var LarkDatabase = class {
     this.subscriptionManager.unsubscribeAll(path);
   }
 };
+
+// src/utils/volatile.ts
+function isVolatilePath(path, patterns) {
+  if (!patterns || patterns.length === 0) {
+    return false;
+  }
+  const segments = path.replace(/^\//, "").split("/");
+  return patterns.some((pattern) => {
+    const patternSegments = pattern.split("/");
+    if (segments.length !== patternSegments.length) {
+      return false;
+    }
+    return patternSegments.every((p, i) => p === "*" || p === segments[i]);
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DataSnapshot,
@@ -1660,6 +1683,7 @@ var LarkDatabase = class {
   LarkDatabase,
   LarkError,
   OnDisconnect,
-  generatePushId
+  generatePushId,
+  isVolatilePath
 });
 //# sourceMappingURL=index.js.map