libshv-js 3.8.0 → 3.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libshv-js",
-  "version": "3.8.0",
+  "version": "3.9.1",
   "description": "Typescript implementation of libshv",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",

package/src/chainpack.ts

@@ -416,7 +416,8 @@ class ChainPackWriter {
                 this.writeDateTime(rpcVal);
                 break;
             case rpcVal instanceof Double:
-                throw new Error('writing doubles not implemented');
+                this.writeDouble(rpcVal);
+                break;
             case typeof rpcVal === 'object':
                 switch (rpcVal[shvMapType]) {
                     case 'imap':
@@ -575,6 +576,19 @@ class ChainPackWriter {
         this.writeUIntDataHelper(bi, 'UInt');
     }
 
+    writeDouble(double: Double) {
+        this.ctx.putByte(PackingSchema.Double);
+        const buffer = new ArrayBuffer(8);
+        const view = new DataView(buffer);
+
+        view.setFloat64(0, double.value, true);
+
+        const data = new Uint8Array(buffer);
+        for (let i = 0; i < 8; i++) {
+            this.ctx.putByte(data[i]);
+        }
+    }
+
     writeList(lst: RpcValue[]) {
         this.ctx.putByte(PackingSchema.List);
         for (const element of lst) {

package/src/rpcmessage.ts

@@ -8,6 +8,7 @@ export const RPC_MESSAGE_CALLER_IDS = 11;
 export const RPC_MESSAGE_PARAMS = 1;
 export const RPC_MESSAGE_RESULT = 2;
 export const RPC_MESSAGE_ERROR = 3;
+export const RPC_MESSAGE_DELAY = 4;
 
 export const ERROR_CODE = 1;
 export const ERROR_MESSAGE = 2;
@@ -51,10 +52,13 @@ const RpcResponseMetaZod = z.metamap({
     [RPC_MESSAGE_CALLER_IDS]: z.int().or(z.array(z.int())).optional(),
     [RPC_MESSAGE_REQUEST_ID]: z.number(),
 });
+
 const RpcResponseValueZod = z.imap({
     [RPC_MESSAGE_RESULT]: z.rpcvalue(),
 }).or(z.imap({
     [RPC_MESSAGE_ERROR]: ErrorMapZod,
+})).or(z.imap({
+    [RPC_MESSAGE_DELAY]: z.double(),
 }));
 
 const RpcSignalMetaZod = z.metamap({

package/src/ws-client.ts

@@ -1,7 +1,7 @@
 import {ChainPackReader, CHAINPACK_PROTOCOL_TYPE, ChainPackWriter, toChainPack} from './chainpack';
 import {type CponReader, CPON_PROTOCOL_TYPE, toCpon} from './cpon';
-import {ERROR_MESSAGE, ErrorCode, ERROR_CODE, RpcMessageZod, type RpcMessage, isSignal, isRequest, type RpcRequest, isResponse, ERROR_DATA, type ErrorMap, RPC_MESSAGE_METHOD, RPC_MESSAGE_SHV_PATH, RPC_MESSAGE_REQUEST_ID, RPC_MESSAGE_PARAMS, RPC_MESSAGE_ERROR, RPC_MESSAGE_RESULT, RPC_MESSAGE_CALLER_IDS, RpcResponseValue} from './rpcmessage';
-import {type RpcValue, type Null, type Int, type IMap, type ShvMap, makeMap, makeIMap, RpcValueWithMetaData, makeMetaMap} from './rpcvalue';
+import {ERROR_MESSAGE, ErrorCode, ERROR_CODE, RpcMessageZod, type RpcMessage, isSignal, isRequest, type RpcRequest, isResponse, ERROR_DATA, type ErrorMap, RPC_MESSAGE_METHOD, RPC_MESSAGE_SHV_PATH, RPC_MESSAGE_REQUEST_ID, RPC_MESSAGE_PARAMS, RPC_MESSAGE_ERROR, RPC_MESSAGE_RESULT, RPC_MESSAGE_CALLER_IDS, RpcResponseValue, RPC_MESSAGE_DELAY} from './rpcmessage';
+import {type RpcValue, type Null, type Int, type IMap, type ShvMap, makeMap, makeIMap, RpcValueWithMetaData, makeMetaMap, Double} from './rpcvalue';
 
 const DEFAULT_TIMEOUT = 5000;
 const DEFAULT_PING_INTERVAL = 30 * 1000;
@@ -58,7 +58,7 @@ type WsClientOptionsLogin = WsClientOptionsCommon & {
     onConnected: () => void;
     onConnectionFailure: (error: Error) => void;
     onDisconnected: () => void;
-    onRequest: (shvPath: string, method: string, param?: RpcValue) => Promise<RpcValue>;
+    onRequest: (shvPath: string, method: string, param: RpcValue, delay: (progress: number) => void) => Promise<RpcValue>;
 };
 
 type WsClientOptionsWorkflows = WsClientOptionsCommon & {
@@ -139,10 +139,10 @@ export const NotImplemented = createErrorClass(ErrorCode.NotImplemented);
 
 class WsClient {
     private requestId = 1;
-    private pingTimerId = -1;
+    private pingTimerId: ReturnType<typeof globalThis.setInterval> | undefined = undefined;
     private rpcHandlers: Array<{
         resolve: RpcResponseResolver;
-        timeout_handle: number;
+        timeout_handle: ReturnType<typeof globalThis.setTimeout>;
     }> = [];
     private readonly subscriptions: Subscription[] = [];
     private readonly websocket: WebSocket;
@@ -187,8 +187,14 @@ class WsClient {
                     };
 
                     try {
+                        const sendDelay = (progress: number) => {
+                            respond(makeIMap({
+                                [RPC_MESSAGE_DELAY]: new Double(progress),
+                            }));
+                        };
+
                         respond(makeIMap({
-                            [RPC_MESSAGE_RESULT]: await this.options.onRequest(rpcMsg.meta[RPC_MESSAGE_SHV_PATH], rpcMsg.meta[RPC_MESSAGE_METHOD], rpcMsg.value[RPC_MESSAGE_PARAMS]),
+                            [RPC_MESSAGE_RESULT]: await this.options.onRequest(rpcMsg.meta[RPC_MESSAGE_SHV_PATH], rpcMsg.meta[RPC_MESSAGE_METHOD], rpcMsg.value[RPC_MESSAGE_PARAMS], sendDelay),
                         }));
                     } catch (error: unknown) {
                         const sendError = (error: RpcError) => {