modality-kit 0.7.7 → 0.7.9

package/dist/index.js

@@ -181,7 +181,7 @@ class ModalityLogger {
         }
         break;
       case "success":
-        console.error(payload);
+        console.log(payload);
         break;
     }
     console.groupEnd();
@@ -4999,7 +4999,6 @@ __export(exports_jsonrpc, {
   JSONRPCUtils: () => JSONRPCUtils,
   JSONRPCErrorCode: () => JSONRPCErrorCode
 });
-var getUUID = () => crypto.randomUUID();
 var JSONRPC_VERSION = "2.0";
 var JSONRPCErrorCode;
 ((JSONRPCErrorCode2) => {
@@ -5091,12 +5090,12 @@ class JSONRPCUtils {
       messageType
     };
   }
-  static createRequest(method, params, id) {
+  static createRequest(method, params, options = {}) {
     return {
       jsonrpc: JSONRPC_VERSION,
       method,
       params,
-      id: id ?? this.generateId()
+      id: options.customId ?? this.generateId()
     };
   }
   static createNotification(method, params) {
@@ -5167,6 +5166,7 @@ var STANDARD_ERROR_MESSAGES = {
   [-32005 /* RATE_LIMIT_ERROR */]: "Rate limit exceeded",
   [-32006 /* VALIDATION_ERROR */]: "Validation error"
 };
+var getUUID = () => crypto.randomUUID();
 
 // src/util_pending.ts
 class PendingOperationsBase {
@@ -5213,10 +5213,14 @@ class PendingOperationsBase {
       clearTimeout(operation.timeoutHandle);
     }
     if (operation.type === "promise") {
-      operation.reject(reason);
+      try {
+        operation.reject(reason);
+      } catch (error) {}
     }
     if (this.eventHandlers.onReject) {
-      this.eventHandlers.onReject(operation, reason);
+      try {
+        this.eventHandlers.onReject(operation, reason);
+      } catch (error) {}
     }
     this.operations.delete(id);
     return true;
@@ -5335,9 +5339,9 @@ class PendingOperationsBase {
     this.eventHandlers = { ...this.eventHandlers, ...handlers };
   }
   handleAdd(options = {}) {
-    const id = options.customId ?? this.config.generateId();
+    const id = options.customId != null ? options.customId : this.config.generateId();
     const timeout = options.timeout ?? this.config.defaultTimeout;
-    if (options.customId && this.operations.has(options.customId)) {
+    if (options.customId != null && this.operations.has(options.customId)) {
       throw new Error(`Operation with ID '${options.customId}' already exists`);
     }
     const timeoutHandle = timeout > 0 ? setTimeout(() => {
@@ -5363,6 +5367,7 @@ class PromisePendingOperations extends PendingOperationsBase {
       };
       this.operations.set(id, operation);
     });
+    promise.catch(() => {});
     return { id, promise };
   }
 }
@@ -5401,32 +5406,51 @@ function createDataPendingOperations(config, eventHandlers) {
 
 class JSONRPCCall {
   pendingRequests;
+  isDestroyed = false;
   constructor(config = {}) {
     const pendingEventHandlers = {
       onTimeout: (operation) => {
+        if (this.isDestroyed)
+          return;
         console.warn(`JSON-RPC operation timed out:`, operation.id);
       },
       onResolve: (operation, _result) => {
+        if (this.isDestroyed)
+          return;
         console.log(`JSON-RPC operation resolved:`, operation.id);
       },
       onReject: (operation, reason) => {
+        if (this.isDestroyed)
+          return;
         console.error(`JSON-RPC operation rejected:`, operation.id, reason);
       }
     };
     this.pendingRequests = createPromisePendingOperations(config, pendingEventHandlers);
   }
   handleResponse(response) {
+    if (this.isDestroyed)
+      return;
     const id = response.id;
-    if (JSONRPCUtils.isSuccessResponse(response)) {
-      this.pendingRequests.resolve(id, response.result);
-    } else {
-      this.pendingRequests.reject(id, new Error(response.error.message));
+    try {
+      if (JSONRPCUtils.isSuccessResponse(response)) {
+        this.pendingRequests.resolve(id, response.result);
+      } else {
+        this.pendingRequests.reject(id, new Error(response.error.message));
+      }
+    } catch (error) {
+      if (!this.isDestroyed) {
+        throw error;
+      }
     }
   }
   handleRequest(method, params, options = {}) {
-    const request = JSONRPCUtils.createRequest(method, params);
-    options.customId = request.id;
-    const { promise } = this.pendingRequests.add({ method, params }, options);
+    const request = JSONRPCUtils.createRequest(method, params, {
+      customId: options.customId
+    });
+    const { promise } = this.pendingRequests.add({ method, params }, {
+      timeout: options.timeout,
+      customId: request.id
+    });
     return { promise, request };
   }
   getStats() {
@@ -5435,6 +5459,7 @@ class JSONRPCCall {
     };
   }
   destroy() {
+    this.isDestroyed = true;
     this.pendingRequests.destroy("JSONRPCManager destroyed");
   }
 }

package/dist/types/__tests__/jsonrpc-call.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Unit Tests for JSONRPCCall Class
+ *
+ * Tests all functionality of the JSONRPCCall class including:
+ * - Request creation and handling
+ * - Response processing (success and error)
+ * - Promise-based operation management
+ * - Timeout handling
+ * - Statistics and cleanup
+ */
+export {};

package/dist/types/index.d.ts

@@ -11,4 +11,4 @@ export { compressWithLanguageDetection as compressText } from "./util_text_compr
 export { JSONRPCCall, createDataPendingOperations } from "./util_pending";
 export type { DataPendingOperation, PendingOperation } from "./util_pending";
 export * as JSONRPCTypes from "./schemas/jsonrpc";
-export type { JSONRPCMessage, JSONRPCRequest, JSONRPCNotification, JSONRPCResponse, JSONRPCBatchRequest, JSONRPCBatchResponse, JSONRPCErrorResponse, JSONRPCValidationResult, } from "./schemas/jsonrpc";
+export type { JSONRPCMessage, JSONRPCRequest, JSONRPCNotification, JSONRPCResponse, JSONRPCBatchRequest, JSONRPCBatchResponse, JSONRPCErrorResponse, JSONRPCValidationResult, CommandExecuteParams, JSONRPCError, JSONRPCParams, } from "./schemas/jsonrpc";

package/dist/types/schemas/jsonrpc.d.ts

@@ -11,8 +11,49 @@
  * Usage: type MyMethod = JSONRPCMethod<MyParams, MyResult>
  * Or as object: { methodName: JSONRPCMethod<MyParams, MyResult> }
  */
-export declare const getUUID: () => `${string}-${string}-${string}-${string}-${string}`;
 export type JSONRPCMethod<TParams = JSONRPCParams, TResult = any> = (method: string, params?: TParams, options?: any) => Promise<TResult>;
+/**
+ * JSON-RPC 2.0 Request object
+ */
+export interface JSONRPCRequest {
+    /** JSON-RPC version identifier */
+    jsonrpc: typeof JSONRPC_VERSION;
+    /** Method name to be invoked */
+    method: string;
+    /** Optional parameters for the method */
+    params?: JSONRPCParams;
+    /** Request identifier for correlation with response */
+    id: JSONRPCId;
+}
+/**
+ * JSON-RPC 2.0 Success Response object
+ */
+export interface JSONRPCSuccessResponse {
+    /** JSON-RPC version identifier */
+    jsonrpc: typeof JSONRPC_VERSION;
+    /** Method result */
+    result: any;
+    /** Request identifier matching the original request */
+    id: JSONRPCId;
+}
+/**
+ * JSON-RPC 2.0 Error Response object
+ */
+export interface JSONRPCErrorResponse {
+    /** JSON-RPC version identifier */
+    jsonrpc: typeof JSONRPC_VERSION;
+    /** Error information */
+    error: JSONRPCError;
+    /** Request identifier matching the original request */
+    id: JSONRPCId;
+}
+/**
+ * Standard method parameter interfaces
+ */
+export interface CommandExecuteParams {
+    command: string;
+    args?: any[];
+}
 /**
  * JSON-RPC 2.0 version identifier
  */
@@ -69,19 +110,6 @@ export interface JSONRPCError {
     /** Optional additional error data */
     data?: any;
 }
-/**
- * JSON-RPC 2.0 Request object
- */
-export interface JSONRPCRequest {
-    /** JSON-RPC version identifier */
-    jsonrpc: typeof JSONRPC_VERSION;
-    /** Method name to be invoked */
-    method: string;
-    /** Optional parameters for the method */
-    params?: JSONRPCParams;
-    /** Request identifier for correlation with response */
-    id: JSONRPCId;
-}
 /**
  * JSON-RPC 2.0 Notification object (request without id)
  */
@@ -93,28 +121,6 @@ export interface JSONRPCNotification {
     /** Optional parameters for the method */
     params?: JSONRPCParams;
 }
-/**
- * JSON-RPC 2.0 Success Response object
- */
-export interface JSONRPCSuccessResponse {
-    /** JSON-RPC version identifier */
-    jsonrpc: typeof JSONRPC_VERSION;
-    /** Method result */
-    result: any;
-    /** Request identifier matching the original request */
-    id: JSONRPCId;
-}
-/**
- * JSON-RPC 2.0 Error Response object
- */
-export interface JSONRPCErrorResponse {
-    /** JSON-RPC version identifier */
-    jsonrpc: typeof JSONRPC_VERSION;
-    /** Error information */
-    error: JSONRPCError;
-    /** Request identifier matching the original request */
-    id: JSONRPCId;
-}
 /**
  * Union type for JSON-RPC 2.0 Response objects
  */
@@ -158,7 +164,9 @@ export declare class JSONRPCUtils {
     /**
      * Create a JSON-RPC request
      */
-    static createRequest(method: string, params?: JSONRPCParams, id?: JSONRPCId): JSONRPCRequest;
+    static createRequest(method: string, params?: JSONRPCParams, options?: {
+        customId?: JSONRPCId;
+    }): JSONRPCRequest;
     /**
      * Create a JSON-RPC notification
      */
@@ -212,3 +220,4 @@ export declare class JSONRPCUtils {
  * Standard error messages for common JSON-RPC errors
  */
 export declare const STANDARD_ERROR_MESSAGES: Record<JSONRPCErrorCode, string>;
+export declare const getUUID: () => `${string}-${string}-${string}-${string}-${string}`;

package/dist/types/util_pending.d.ts

@@ -306,6 +306,7 @@ export declare function createPromisePendingOperations(config?: PendingOperation
 export declare function createDataPendingOperations(config?: PendingOperationsConfig, eventHandlers?: PendingOperationEventHandlers): DataPendingOperations;
 export declare class JSONRPCCall {
     private pendingRequests;
+    private isDestroyed;
     constructor(config?: PendingOperationsConfig);
     /**
      * Process a JSON-RPC response

package/dist/types/util_tests/TimerMockManager.d.ts

@@ -31,9 +31,15 @@
  */
 export declare class TimerMockManager {
     private originalSetTimeout?;
+    private originalClearTimeout?;
     private originalMathRandom?;
     private mockSetTimeout?;
+    private mockClearTimeout?;
+    private activeTimers;
+    private timerIdCounter;
     private virtualClock;
+    private isDestroyed;
+    private suppressTimeouts;
     /**
      * Setup timer mocks
      * @param executeImmediately - Whether to execute callbacks immediately (default: true for fast tests)
@@ -56,6 +62,22 @@ export declare class TimerMockManager {
      * Get the mock setTimeout function for assertions
      */
     getMockSetTimeout(): any;
+    /**
+     * Clear all active timers
+     */
+    clearAllActiveTimers(): void;
+    /**
+     * Get the number of active timers
+     */
+    getActiveTimerCount(): number;
+    /**
+     * Suppress timeout execution temporarily
+     */
+    suppressTimeoutExecution(): void;
+    /**
+     * Resume timeout execution
+     */
+    resumeTimeoutExecution(): void;
     /**
      * Verify that setTimeout was called with expected parameters
      */

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.7.7",
+  "version": "0.7.9",
   "name": "modality-kit",
   "repository": {
     "type": "git",