libshv-js 7.1.6 → 7.1.8

package/dist/chainpack.d.ts

@@ -3,6 +3,7 @@ import { UnpackContext, PackContext } from './cpcontext';
 declare class ChainPackReader {
     ctx: UnpackContext;
     constructor(data: ArrayBuffer | UnpackContext);
+    private implReadMap;
     read(): RpcValue;
     readUIntDataHelper(type: 'Int' | 'UInt'): bigint;
     readIntData(): number;
@@ -11,7 +12,6 @@ declare class ChainPackReader {
     readMetaMap(): MetaMap;
     readMap(): ShvMap;
     readIMap(): IMap;
-    private implReadMap;
 }
 declare class ChainPackWriter {
     ctx: PackContext;

package/dist/chainpack.js

@@ -79,6 +79,33 @@ class ChainPackReader {
     constructor(data) {
         this.ctx = data instanceof cpcontext_1.UnpackContext ? data : new cpcontext_1.UnpackContext(data);
     }
+    implReadMap(mapType) {
+        const map = {
+            [rpcvalue_1.shvMapType]: mapType,
+        };
+        while (true) {
+            const b = this.ctx.peekByte();
+            if (b === PackingSchema.Term) {
+                this.ctx.getByte();
+                break;
+            }
+            const key = this.read();
+            const val = this.read();
+            if ((map[rpcvalue_1.shvMapType] === 'metamap' && typeof key === 'string') ||
+                (map[rpcvalue_1.shvMapType] === 'metamap' && typeof key === 'number') ||
+                (map[rpcvalue_1.shvMapType] === 'map' && typeof key === 'string')) {
+                map[key] = val;
+                // eslint-disable-next-line unicorn/no-duplicate-if-branches -- the type system needs this branch
+            }
+            else if (map[rpcvalue_1.shvMapType] === 'imap' && typeof key === 'number') {
+                map[key] = val;
+            }
+            else {
+                throw new TypeError('Malformed map, invalid key');
+            }
+        }
+        return map;
+    }
     /* eslint-disable complexity -- we might simplify this at some point, but it works now */
     read() {
         let meta;
@@ -285,36 +312,6 @@ class ChainPackReader {
     readIMap() {
         return this.implReadMap('imap');
     }
-    implReadMap(mapType) {
-        const map = {
-            [rpcvalue_1.shvMapType]: mapType,
-        };
-        while (true) {
-            const b = this.ctx.peekByte();
-            if (b === PackingSchema.Term) {
-                this.ctx.getByte();
-                break;
-            }
-            const key = this.read();
-            const val = this.read();
-            if (map[rpcvalue_1.shvMapType] === 'metamap' && typeof key === 'string') {
-                map[key] = val;
-            }
-            else if (map[rpcvalue_1.shvMapType] === 'metamap' && typeof key === 'number') {
-                map[Number(key)] = val;
-            }
-            else if (map[rpcvalue_1.shvMapType] === 'map' && typeof key === 'string') {
-                map[key] = val;
-            }
-            else if (map[rpcvalue_1.shvMapType] === 'imap' && typeof key === 'number') {
-                map[Number(key)] = val;
-            }
-            else {
-                throw new TypeError('Malformed map, invalid key');
-            }
-        }
-        return map;
-    }
 }
 exports.ChainPackReader = ChainPackReader;
 class ChainPackWriter {
@@ -426,12 +423,12 @@ class ChainPackWriter {
         this.writeUIntDataHelper(BigInt(snum), 'Int');
     }
     writeInt(n) {
-        if (Number(n) >= 0 && Number(n) < 64) {
-            this.ctx.putByte(Number(n) + 64);
+        if (n >= 0 && n < 64) {
+            this.ctx.putByte(n + 64);
             return;
         }
         this.ctx.putByte(PackingSchema.Int);
-        this.writeIntData(Number(n));
+        this.writeIntData(n);
     }
     writeUInt(n) {
         if (Number(n) < 64) {
@@ -529,14 +526,14 @@ class ChainPackWriter {
             else if (map[rpcvalue_1.shvMapType] === 'metamap') {
                 const intKey = Number(key);
                 if (Number.isNaN(intKey)) {
-                    this.writeJSString(key.toString());
+                    this.writeJSString(key);
                 }
                 else {
                     this.writeInt(intKey);
                 }
             }
             else {
-                this.writeJSString(key.toString());
+                this.writeJSString(key);
             }
             this.write(value);
         }

package/dist/cpcontext.d.ts

@@ -1,6 +1,6 @@
 declare class UnpackContext {
-    index: number;
     private readonly data;
+    index: number;
     constructor(buf: ArrayBufferLike);
     getByte(): number;
     peekByte(): number;

package/dist/cpcontext.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnpackContext = exports.PackContext = void 0;
 class UnpackContext {
-    index;
     data;
+    index;
     constructor(buf) {
         this.data = new Uint8Array(buf);
         this.index = 0;
@@ -72,6 +72,7 @@ class PackContext {
         /* eslint-enable no-bitwise */
     }
     buffer() {
+        // eslint-disable-next-line unicorn/no-unsafe-buffer-conversion
         return this.data.buffer.slice(0, this.length);
     }
 }

package/dist/cpon.d.ts

@@ -5,6 +5,7 @@ declare const utf8ToString: (bytearray: ArrayBuffer) => string;
 declare class CponReader {
     ctx: UnpackContext;
     constructor(unpackContext: UnpackContext);
+    private implReadMap;
     read(): RpcValue;
     skipWhitespace(): void;
     readDateTime(): DateTime;
@@ -18,7 +19,6 @@ declare class CponReader {
     readIMap(): IMap;
     readInt(): number;
     readNumber(): number | Decimal | UInt<number>;
-    private implReadMap;
 }
 declare class CponWriter {
     private readonly indentString?;
@@ -26,6 +26,10 @@ declare class CponWriter {
     ctx: PackContext;
     nestLevel: number;
     constructor(indentString?: string | undefined, oneLiners?: OneLiners);
+    private doIndentIfNotOneliner;
+    private isOneLiner;
+    private increaseIndentIfNotOneLiner;
+    private decreaseIndentIfNotOneLiner;
     write(rpcVal: RpcValue): void;
     writeJSString(str: string): void;
     writeBlob(buffer: ArrayBuffer): void;
@@ -40,10 +44,6 @@ declare class CponWriter {
     writeInt(num: Int): void;
     writeDouble(num: Double): void;
     writeDecimal(val: Decimal): void;
-    private doIndentIfNotOneliner;
-    private isOneLiner;
-    private increaseIndentIfNotOneLiner;
-    private decreaseIndentIfNotOneLiner;
 }
 export declare enum OneLiners {
     Yes = 0,

package/dist/cpon.js

@@ -82,6 +82,42 @@ class CponReader {
     constructor(unpackContext) {
         this.ctx = unpackContext;
     }
+    implReadMap(mapType, terminator) {
+        const map = {
+            [rpcvalue_1.shvMapType]: mapType,
+        };
+        this.ctx.getByte(); // eat start
+        while (true) {
+            this.skipWhitespace();
+            const b = this.ctx.peekByte();
+            if (b === terminator) {
+                this.ctx.getByte();
+                break;
+            }
+            const key = this.read();
+            if (key instanceof rpcvalue_1.RpcValueWithMetaData) {
+                throw new TypeError('Map/IMap/MetaMap key can\'t have its own MetaData');
+            }
+            this.skipWhitespace();
+            const val = this.read();
+            if (map[rpcvalue_1.shvMapType] === 'metamap' && typeof key === 'string') {
+                map[key] = val;
+            }
+            else if (map[rpcvalue_1.shvMapType] === 'metamap' && (key instanceof rpcvalue_1.UInt || typeof key === 'number')) {
+                map[Number(key)] = val;
+            }
+            else if (map[rpcvalue_1.shvMapType] === 'map' && typeof key === 'string') {
+                map[key] = val;
+            }
+            else if (map[rpcvalue_1.shvMapType] === 'imap' && (key instanceof rpcvalue_1.UInt || typeof key === 'number')) {
+                map[Number(key)] = val;
+            }
+            else {
+                throw new TypeError('Malformed map, invalid key');
+            }
+        }
+        return map;
+    }
     read() {
         let meta;
         this.skipWhitespace();
@@ -233,40 +269,40 @@ class CponReader {
         return date;
     }
     readDateTimeInner() {
-        let utcOffset = 0;
-        const year = Number(this.readInt());
+        const year = this.readInt();
         let b = this.ctx.getByte();
         if (b !== '-'.codePointAt(0)) {
             throw new TypeError('Malformed year-month separator in DateTime');
         }
-        const month = Number(this.readInt());
+        const month = this.readInt();
         b = this.ctx.getByte();
         if (b !== '-'.codePointAt(0)) {
             throw new TypeError('Malformed year-month separator in DateTime');
         }
-        const day = Number(this.readInt());
+        const day = this.readInt();
         b = this.ctx.getByte();
         if (b !== ' '.codePointAt(0) && b !== 'T'.codePointAt(0)) {
             throw new TypeError('Malformed date-time separator in DateTime');
         }
-        const hour = Number(this.readInt());
+        const hour = this.readInt();
         b = this.ctx.getByte();
         if (b !== ':'.codePointAt(0)) {
             throw new TypeError('Malformed year-month separator in DateTime');
         }
-        const min = Number(this.readInt());
+        const min = this.readInt();
         b = this.ctx.getByte();
         if (b !== ':'.codePointAt(0)) {
             throw new TypeError('Malformed year-month separator in DateTime');
         }
-        const sec = Number(this.readInt());
+        const sec = this.readInt();
         let msec = 0;
         b = this.ctx.peekByte();
         if (b === '.'.codePointAt(0)) {
             this.ctx.getByte();
-            msec = Number(this.readInt());
+            msec = this.readInt();
         }
         b = this.ctx.peekByte();
+        let utcOffset = 0;
         if (b === 'Z'.codePointAt(0)) {
             // zulu time
             this.ctx.getByte();
@@ -275,7 +311,7 @@ class CponReader {
             // UTC time offset
             this.ctx.getByte();
             const ix1 = this.ctx.index;
-            const val = Number(this.readInt());
+            const val = this.readInt();
             const n = this.ctx.index - ix1;
             if (!(n === 2 || n === 4)) {
                 throw new TypeError('Malformed TS offset in DateTime.');
@@ -394,10 +430,8 @@ class CponReader {
                 // end of string
                 break;
             }
-            else {
-                const b2 = (unhex(b) * 16) + unhex(this.ctx.getByte());
-                pctx.putByte(b2);
-            }
+            const b2 = (unhex(b) * 16) + unhex(this.ctx.getByte());
+            pctx.putByte(b2);
         }
         return pctx.buffer();
     }
@@ -500,7 +534,7 @@ class CponReader {
             isNeg = true;
             b = this.ctx.getByte();
         }
-        let mantisa = Number(this.readInt());
+        let mantisa = this.readInt();
         b = this.ctx.peekByte();
         (() => {
             while (true) {
@@ -514,7 +548,7 @@ class CponReader {
                         isDecimal = true;
                         this.ctx.getByte();
                         const ix1 = this.ctx.index;
-                        decimals = Number(this.readInt());
+                        decimals = this.readInt();
                         // if(n < 0)
                         //  UNPACK_ERROR(CCPCP_RC_MALFORMED_INPUT, "Malformed number decimal part.")
                         decCnt = this.ctx.index - ix1;
@@ -529,7 +563,7 @@ class CponReader {
                         isDecimal = true;
                         this.ctx.getByte();
                         const ix1 = this.ctx.index;
-                        exponent = Number(this.readInt());
+                        exponent = this.readInt();
                         if (ix1 === this.ctx.index) {
                             throw new TypeError('Malformed number exponential part.');
                         }
@@ -553,42 +587,6 @@ class CponReader {
         }
         return isNeg ? -mantisa : mantisa;
     }
-    implReadMap(mapType, terminator) {
-        const map = {
-            [rpcvalue_1.shvMapType]: mapType,
-        };
-        this.ctx.getByte(); // eat start
-        while (true) {
-            this.skipWhitespace();
-            const b = this.ctx.peekByte();
-            if (b === terminator) {
-                this.ctx.getByte();
-                break;
-            }
-            const key = this.read();
-            if (key instanceof rpcvalue_1.RpcValueWithMetaData) {
-                throw new TypeError('Map/IMap/MetaMap key can\'t have its own MetaData');
-            }
-            this.skipWhitespace();
-            const val = this.read();
-            if (map[rpcvalue_1.shvMapType] === 'metamap' && typeof key === 'string') {
-                map[key] = val;
-            }
-            else if (map[rpcvalue_1.shvMapType] === 'metamap' && (key instanceof rpcvalue_1.UInt || typeof key === 'number')) {
-                map[Number(key)] = val;
-            }
-            else if (map[rpcvalue_1.shvMapType] === 'map' && typeof key === 'string') {
-                map[key] = val;
-            }
-            else if (map[rpcvalue_1.shvMapType] === 'imap' && (key instanceof rpcvalue_1.UInt || typeof key === 'number')) {
-                map[Number(key)] = val;
-            }
-            else {
-                throw new TypeError('Malformed map, invalid key');
-            }
-        }
-        return map;
-    }
 }
 exports.CponReader = CponReader;
 class CponWriter {
@@ -601,6 +599,33 @@ class CponWriter {
         this.oneLiners = oneLiners;
         this.ctx = new cpcontext_1.PackContext();
     }
+    doIndentIfNotOneliner(map) {
+        if (this.indentString === undefined || this.isOneLiner(map)) {
+            return;
+        }
+        this.ctx.putByte('\n'.codePointAt(0));
+        this.ctx.writeStringUtf8(this.indentString.repeat(this.nestLevel));
+    }
+    isOneLiner(value) {
+        if (this.oneLiners === OneLiners.No) {
+            return false;
+        }
+        const keyThreshold = Array.isArray(value) ? 10 : 5;
+        if (Array.isArray(value)) {
+            return value.length <= keyThreshold && value.every(x => !Array.isArray(x) && !(0, rpcvalue_1.isShvMap)(x) && !(0, rpcvalue_1.isIMap)(x));
+        }
+        return Object.keys(value).length <= keyThreshold && Object.values(value).every(x => (!Array.isArray(x) && !(0, rpcvalue_1.isShvMap)(x) && !(0, rpcvalue_1.isIMap)(x)));
+    }
+    increaseIndentIfNotOneLiner(value) {
+        if (!this.isOneLiner(value)) {
+            this.nestLevel++;
+        }
+    }
+    decreaseIndentIfNotOneLiner(value) {
+        if (!this.isOneLiner(value)) {
+            this.nestLevel--;
+        }
+    }
     write(rpcVal) {
         if (rpcVal instanceof rpcvalue_1.RpcValueWithMetaData) {
             this.writeMeta(rpcVal.meta);
@@ -756,7 +781,7 @@ class CponWriter {
                 const intKey = Number(key);
                 if (Number.isNaN(intKey)) {
                     this.ctx.putByte('"'.codePointAt(0));
-                    this.ctx.writeStringUtf8(key.toString());
+                    this.ctx.writeStringUtf8(key);
                     this.ctx.putByte('"'.codePointAt(0));
                 }
                 else {
@@ -764,7 +789,7 @@ class CponWriter {
                 }
             }
             else {
-                this.writeJSString(key.toString());
+                this.writeJSString(key);
             }
             this.ctx.writeStringUtf8(':');
             this.write(value);
@@ -794,7 +819,7 @@ class CponWriter {
         this.ctx.putByte('u'.codePointAt(0));
     }
     writeInt(num) {
-        const s = Number(num).toString();
+        const s = num.toString();
         this.ctx.writeStringUtf8(s);
     }
     writeDouble(num) {
@@ -842,32 +867,6 @@ class CponWriter {
             this.ctx.putByte(str.codePointAt(i));
         }
     }
-    doIndentIfNotOneliner(map) {
-        if (this.indentString !== undefined && !this.isOneLiner(map)) {
-            this.ctx.putByte('\n'.codePointAt(0));
-            this.ctx.writeStringUtf8(this.indentString.repeat(this.nestLevel));
-        }
-    }
-    isOneLiner(value) {
-        if (this.oneLiners === OneLiners.No) {
-            return false;
-        }
-        const keyThreshold = Array.isArray(value) ? 10 : 5;
-        if (Array.isArray(value)) {
-            return value.length <= keyThreshold && !(value.some(x => Array.isArray(x) || (0, rpcvalue_1.isShvMap)(x) || (0, rpcvalue_1.isIMap)(x)));
-        }
-        return Object.keys(value).length <= keyThreshold && !(Object.values(value).some(x => Array.isArray(x) || (0, rpcvalue_1.isShvMap)(x) || (0, rpcvalue_1.isIMap)(x)));
-    }
-    increaseIndentIfNotOneLiner(value) {
-        if (!this.isOneLiner(value)) {
-            this.nestLevel++;
-        }
-    }
-    decreaseIndentIfNotOneLiner(value) {
-        if (!this.isOneLiner(value)) {
-            this.nestLevel--;
-        }
-    }
 }
 exports.CponWriter = CponWriter;
 var OneLiners;

package/dist/rpcmessage.js

@@ -35,9 +35,9 @@ const implRpcMessage = (message) => typeof message === 'object'
     && 'meta' in message
     && typeof message.meta === 'object'
     && message.meta !== null;
-const isSignal = (message) => implRpcMessage(message) && !(exports.RPC_MESSAGE_REQUEST_ID in message.meta) && exports.RPC_MESSAGE_METHOD in message.meta;
+const isSignal = (message) => implRpcMessage(message) && !Object.hasOwn(message.meta, exports.RPC_MESSAGE_REQUEST_ID) && Object.hasOwn(message.meta, exports.RPC_MESSAGE_METHOD);
 exports.isSignal = isSignal;
-const isRequest = (message) => implRpcMessage(message) && exports.RPC_MESSAGE_REQUEST_ID in message.meta && exports.RPC_MESSAGE_METHOD in message.meta;
+const isRequest = (message) => implRpcMessage(message) && Object.hasOwn(message.meta, exports.RPC_MESSAGE_REQUEST_ID) && Object.hasOwn(message.meta, exports.RPC_MESSAGE_METHOD);
 exports.isRequest = isRequest;
-const isResponse = (message) => implRpcMessage(message) && exports.RPC_MESSAGE_REQUEST_ID in message.meta && !(exports.RPC_MESSAGE_METHOD in message.meta);
+const isResponse = (message) => implRpcMessage(message) && Object.hasOwn(message.meta, exports.RPC_MESSAGE_REQUEST_ID) && !Object.hasOwn(message.meta, exports.RPC_MESSAGE_METHOD);
 exports.isResponse = isResponse;

package/dist/rpcvalue.js

@@ -8,7 +8,7 @@ class UInt {
             this.value = u.value;
             return;
         }
-        if (u < 0 || !Number.isInteger(u)) {
+        if (u < 0 || !Number.isSafeInteger(u)) {
             throw new Error(`Invalid value '${u}' for UInt must a positive integral number`);
         }
         this.value = u;
@@ -17,7 +17,7 @@ class UInt {
         return this.value;
     }
     toString() {
-        return `${this.value.toString()}`;
+        return this.value.toString();
     }
 }
 exports.UInt = UInt;
@@ -32,7 +32,7 @@ class Decimal {
     mantisa;
     exponent;
     constructor(mantisa, exponent) {
-        if (!Number.isInteger(exponent)) {
+        if (!Number.isSafeInteger(exponent)) {
             throw new TypeError(`Decimal: exponent must be integral (${exponent})`);
         }
         this.mantisa = mantisa;

package/dist/ws-client.d.ts

@@ -226,6 +226,8 @@ declare class WsClient {
     private readonly timeout;
     private shvApiVersion;
     constructor(options: WsClientOptions<MethodHandler>);
+    private workflowsProcedure;
+    private loginProcedure;
     callRpcMethod(shvPath: '.broker/currentClient', method: 'accessGrantForMethodCall', params: [string, string], options?: CallRpcMethodOptions): RpcRequestPromise<ResultOrError<string>>;
     callRpcMethod(shvPath: '.broker/currentClient', method: 'accessLevelForMethodCall', params: [string, string], options?: CallRpcMethodOptions): RpcRequestPromise<ResultOrError<number>>;
     callRpcMethod(shvPath: string | undefined, method: 'dir', params?: RpcValue, options?: CallRpcMethodOptions): RpcRequestPromise<ResultOrError<DirResult>>;
@@ -240,7 +242,5 @@ declare class WsClient {
     accessLevelForMethodCall(path: string, method: string): RpcRequestPromise<ResultOrError<number>>;
     close(): void;
     protected logDebug(...args: string[]): void;
-    private workflowsProcedure;
-    private loginProcedure;
 }
 export { WsClient };

package/dist/ws-client.js

@@ -113,7 +113,7 @@ exports.LoginRequired = createErrorClass(rpcmessage_1.ErrorCode.LoginRequired);
 exports.UserIDRequired = createErrorClass(rpcmessage_1.ErrorCode.UserIDRequired);
 exports.NotImplemented = createErrorClass(rpcmessage_1.ErrorCode.NotImplemented);
 /* eslint-enable @typescript-eslint/naming-convention */
-const makeTimeout = (ms, resolve) => globalThis.setTimeout(() => {
+const makeTimeout = (ms, resolve) => setTimeout(() => {
     resolve(new exports.MethodCallTimeout((0, rpcvalue_1.makeIMap)({
         [rpcmessage_1.ERROR_CODE]: rpcmessage_1.ErrorCode.MethodCallTimeout,
         [rpcmessage_1.ERROR_MESSAGE]: `Shv call timeout after: ${ms} msec.`,
@@ -164,152 +164,155 @@ class WsClient {
         };
         // eslint-disable-next-line complexity
         const handleRequest = async (request) => {
-            if ('onRequest' in this.options) {
-                const requestId = request.meta[rpcmessage_1.RPC_MESSAGE_REQUEST_ID];
-                const respond = (value) => {
-                    this.sendRpcMessage(new rpcvalue_1.RpcValueWithMetaData((0, rpcvalue_1.makeMetaMap)({
-                        [rpcmessage_1.RPC_MESSAGE_CALLER_IDS]: request.meta[rpcmessage_1.RPC_MESSAGE_CALLER_IDS],
-                        [rpcmessage_1.RPC_MESSAGE_REQUEST_ID]: requestId,
-                    }), value));
-                };
-                const sendDelay = (progress) => {
-                    respond((0, rpcvalue_1.makeIMap)({
-                        [rpcmessage_1.RPC_MESSAGE_DELAY]: new rpcvalue_1.Double(progress),
-                    }));
-                };
-                if (rpcmessage_1.RPC_MESSAGE_ABORT in request.value) {
-                    const requestHandler = this.requestHandlers.get(requestId);
-                    if (request.value[rpcmessage_1.RPC_MESSAGE_ABORT]) {
-                        this.abortedRequests.add(requestId);
-                        if (requestHandler?.options.onAbort !== undefined) {
-                            requestHandler.options.onAbort();
-                        }
-                    }
-                    if (!request.value[rpcmessage_1.RPC_MESSAGE_ABORT] && requestHandler?.options.onProgressQuery !== undefined) {
-                        const progress = requestHandler.options.onProgressQuery();
-                        sendDelay(progress instanceof Promise ? await progress : progress);
+            if (!('onRequest' in this.options)) {
+                return;
+            }
+            const requestId = request.meta[rpcmessage_1.RPC_MESSAGE_REQUEST_ID];
+            const respond = (value) => {
+                this.sendRpcMessage(new rpcvalue_1.RpcValueWithMetaData((0, rpcvalue_1.makeMetaMap)({
+                    [rpcmessage_1.RPC_MESSAGE_CALLER_IDS]: request.meta[rpcmessage_1.RPC_MESSAGE_CALLER_IDS],
+                    [rpcmessage_1.RPC_MESSAGE_REQUEST_ID]: requestId,
+                }), value));
+            };
+            const sendDelay = (progress) => {
+                respond((0, rpcvalue_1.makeIMap)({
+                    [rpcmessage_1.RPC_MESSAGE_DELAY]: new rpcvalue_1.Double(progress),
+                }));
+            };
+            // eslint-disable-next-line unicorn/no-computed-property-existence-check
+            if (rpcmessage_1.RPC_MESSAGE_ABORT in request.value) {
+                const requestHandler = this.requestHandlers.get(requestId);
+                if (request.value[rpcmessage_1.RPC_MESSAGE_ABORT]) {
+                    this.abortedRequests.add(requestId);
+                    if (requestHandler?.options.onAbort !== undefined) {
+                        requestHandler.options.onAbort();
                     }
+                }
+                if (!request.value[rpcmessage_1.RPC_MESSAGE_ABORT] && requestHandler?.options.onProgressQuery !== undefined) {
+                    const progress = requestHandler.options.onProgressQuery();
+                    sendDelay(progress instanceof Promise ? await progress : progress);
+                }
+                return;
+            }
+            try {
+                const shvPath = request.meta[rpcmessage_1.RPC_MESSAGE_SHV_PATH];
+                const methodName = request.meta[rpcmessage_1.RPC_MESSAGE_METHOD];
+                const unhandledMethod = () => {
+                    throw new exports.MethodNotFound(`No such path '${shvPath}' or method '${methodName}' or insufficient access rights.`);
+                };
+                const accessLevel = request.meta[rpcmessage_1.RPC_MESSAGE_ACCESS_LEVEL];
+                if (accessLevel === undefined) {
+                    unhandledMethod();
                     return;
                 }
-                try {
-                    const shvPath = request.meta[rpcmessage_1.RPC_MESSAGE_SHV_PATH];
-                    const methodName = request.meta[rpcmessage_1.RPC_MESSAGE_METHOD];
-                    const unhandledMethod = () => {
-                        throw new exports.MethodNotFound(`No such path '${shvPath}' or method '${methodName}' or insufficient access rights.`);
-                    };
-                    const accessLevel = request.meta[rpcmessage_1.RPC_MESSAGE_ACCESS_LEVEL];
-                    if (accessLevel === undefined) {
-                        unhandledMethod();
-                        return;
-                    }
-                    const methods = this.options.onRequest(shvPath);
-                    if (methods === undefined) {
-                        unhandledMethod();
-                        return;
-                    }
-                    const methodDefinition = (() => {
-                        const dirEntry = (0, rpcvalue_1.makeIMap)({
-                            [exports.DIR_NAME]: 'dir',
-                            [exports.DIR_FLAGS]: 0,
-                            [exports.DIR_PARAM]: 'DirParam',
-                            [exports.DIR_RESULT]: 'DirResult',
-                            [exports.DIR_ACCESS]: (0, access_1.accessLevelFromAccessString)('bws'),
-                            [exports.DIR_SIGNALS]: (0, rpcvalue_1.makeMap)({}),
-                            [exports.DIR_EXTRA]: (0, rpcvalue_1.makeMap)({}),
-                        });
-                        const lsEntry = (0, rpcvalue_1.makeIMap)({
-                            [exports.DIR_NAME]: 'ls',
-                            [exports.DIR_FLAGS]: 0,
-                            [exports.DIR_PARAM]: 'LsParam',
-                            [exports.DIR_RESULT]: 'LsResult',
-                            [exports.DIR_ACCESS]: (0, access_1.accessLevelFromAccessString)('bws'),
-                            [exports.DIR_SIGNALS]: (0, rpcvalue_1.makeMap)({}),
-                            [exports.DIR_EXTRA]: (0, rpcvalue_1.makeMap)({}),
-                        });
-                        switch (methodName) {
-                            case 'dir':
-                                return {
-                                    entry: dirEntry,
-                                    paramValidator: exports.validateDirParam,
-                                    handler(_shvPath, _method, param) {
-                                        const methodsResult = [dirEntry, lsEntry, ...methods.dirEntries.map(method => method.entry)];
-                                        switch (true) {
-                                            case typeof param === 'string':
-                                                return methodsResult.find(method => method[exports.DIR_NAME] === param) ?? false;
-                                            case typeof param === 'boolean':
-                                            case param === undefined:
-                                                console.log('methodsResult', '=', methodsResult);
-                                                return methodsResult;
-                                        }
-                                    },
-                                };
-                            case 'ls':
-                                return {
-                                    entry: lsEntry,
-                                    paramValidator: exports.validateLsParam,
-                                    handler(shvPath) {
-                                        return methods.ls(shvPath);
-                                    },
-                                };
-                            default:
-                                return methods.dirEntries.find(method => method.entry[exports.DIR_NAME] === methodName);
-                        }
-                    })();
-                    if (methodDefinition === undefined) {
-                        unhandledMethod();
-                        return;
-                    }
-                    if (accessLevel < methodDefinition.entry[exports.DIR_ACCESS]) {
-                        unhandledMethod();
-                        return;
-                    }
-                    const requestParam = request.value[rpcmessage_1.RPC_MESSAGE_PARAMS];
-                    if (methodDefinition.paramValidator !== undefined && !methodDefinition.paramValidator(requestParam)) {
-                        throw new exports.InvalidParams(`Unexpected param '${shvPath}:${methodName}': ${(0, cpon_1.toCpon)(requestParam)}`);
-                    }
-                    let result = methodDefinition.handler(shvPath, methodName, requestParam, sendDelay);
-                    if (result instanceof RequestHandler) {
-                        this.requestHandlers.set(requestId, result);
-                        result = result.options.result;
-                    }
-                    const resultOrError = (0, rpcvalue_1.makeIMap)({
-                        [rpcmessage_1.RPC_MESSAGE_RESULT]: result instanceof Promise ? await result : result,
-                    });
-                    if (!this.abortedRequests.has(requestId)) {
-                        respond(resultOrError);
-                    }
-                    else {
-                        this.abortedRequests.delete(requestId);
-                    }
-                    if (requestId in this.requestHandlers) {
-                        this.requestHandlers.delete(requestId);
-                    }
+                const methods = this.options.onRequest(shvPath);
+                if (methods === undefined) {
+                    unhandledMethod();
+                    return;
                 }
-                catch (error) {
-                    const sendError = (error) => {
-                        respond((0, rpcvalue_1.makeIMap)({
-                            [rpcmessage_1.RPC_MESSAGE_ERROR]: error.err_info,
-                        }));
-                    };
-                    switch (true) {
-                        case error instanceof RpcError:
-                            sendError(error);
-                            break;
-                        case error instanceof Error:
-                            sendError(new exports.InternalError(error.message));
-                            break;
+                const methodDefinition = (() => {
+                    const dirEntry = (0, rpcvalue_1.makeIMap)({
+                        [exports.DIR_NAME]: 'dir',
+                        [exports.DIR_FLAGS]: 0,
+                        [exports.DIR_PARAM]: 'DirParam',
+                        [exports.DIR_RESULT]: 'DirResult',
+                        [exports.DIR_ACCESS]: (0, access_1.accessLevelFromAccessString)('bws'),
+                        [exports.DIR_SIGNALS]: (0, rpcvalue_1.makeMap)({}),
+                        [exports.DIR_EXTRA]: (0, rpcvalue_1.makeMap)({}),
+                    });
+                    const lsEntry = (0, rpcvalue_1.makeIMap)({
+                        [exports.DIR_NAME]: 'ls',
+                        [exports.DIR_FLAGS]: 0,
+                        [exports.DIR_PARAM]: 'LsParam',
+                        [exports.DIR_RESULT]: 'LsResult',
+                        [exports.DIR_ACCESS]: (0, access_1.accessLevelFromAccessString)('bws'),
+                        [exports.DIR_SIGNALS]: (0, rpcvalue_1.makeMap)({}),
+                        [exports.DIR_EXTRA]: (0, rpcvalue_1.makeMap)({}),
+                    });
+                    switch (methodName) {
+                        case 'dir':
+                            return {
+                                entry: dirEntry,
+                                paramValidator: exports.validateDirParam,
+                                handler(_shvPath, _method, param) {
+                                    const methodsResult = [dirEntry, lsEntry, ...methods.dirEntries.map(method => method.entry)];
+                                    switch (true) {
+                                        case typeof param === 'string':
+                                            return methodsResult.find(method => method[exports.DIR_NAME] === param) ?? false;
+                                        case typeof param === 'boolean':
+                                        case param === undefined:
+                                            console.log('methodsResult', '=', methodsResult);
+                                            return methodsResult;
+                                    }
+                                },
+                            };
+                        case 'ls':
+                            return {
+                                entry: lsEntry,
+                                paramValidator: exports.validateLsParam,
+                                handler(shvPath) {
+                                    return methods.ls(shvPath);
+                                },
+                            };
                         default:
-                            sendError(new exports.InternalError('Unknown error'));
-                            break;
+                            return methods.dirEntries.find(method => method.entry[exports.DIR_NAME] === methodName);
                     }
+                })();
+                if (methodDefinition === undefined) {
+                    unhandledMethod();
+                    return;
+                }
+                if (accessLevel < methodDefinition.entry[exports.DIR_ACCESS]) {
+                    unhandledMethod();
+                    return;
+                }
+                const requestParam = request.value[rpcmessage_1.RPC_MESSAGE_PARAMS];
+                if (methodDefinition.paramValidator !== undefined && !methodDefinition.paramValidator(requestParam)) {
+                    throw new exports.InvalidParams(`Unexpected param '${shvPath}:${methodName}': ${(0, cpon_1.toCpon)(requestParam)}`);
+                }
+                let result = methodDefinition.handler(shvPath, methodName, requestParam, sendDelay);
+                if (result instanceof RequestHandler) {
+                    this.requestHandlers.set(requestId, result);
+                    result = result.options.result;
+                }
+                const resultOrError = (0, rpcvalue_1.makeIMap)({
+                    [rpcmessage_1.RPC_MESSAGE_RESULT]: result instanceof Promise ? await result : result,
+                });
+                if (!this.abortedRequests.has(requestId)) {
+                    respond(resultOrError);
+                }
+                else {
+                    this.abortedRequests.delete(requestId);
+                }
+                if (this.requestHandlers.has(requestId)) {
+                    this.requestHandlers.delete(requestId);
+                }
+            }
+            catch (error) {
+                const sendError = (error) => {
+                    respond((0, rpcvalue_1.makeIMap)({
+                        [rpcmessage_1.RPC_MESSAGE_ERROR]: error.err_info,
+                    }));
+                };
+                switch (true) {
+                    case error instanceof RpcError:
+                        sendError(error);
+                        break;
+                    case error instanceof Error:
+                        sendError(new exports.InternalError(error.message));
+                        break;
+                    default:
+                        sendError(new exports.InternalError('Unknown error'));
+                        break;
                 }
             }
         };
         const handleResponse = (response) => {
             const requestId = response.meta[rpcmessage_1.RPC_MESSAGE_REQUEST_ID];
-            if (this.rpcHandlers[Number(requestId)] !== undefined) {
-                const handler = this.rpcHandlers[Number(requestId)];
+            if (this.rpcHandlers[requestId] !== undefined) {
+                const handler = this.rpcHandlers[requestId];
                 clearTimeout(handler.timeout_handle);
+                // eslint-disable-next-line unicorn/no-computed-property-existence-check
                 if (rpcmessage_1.RPC_MESSAGE_DELAY in response.value) {
                     if (handler.delayCallback !== undefined) {
                         handler.delayCallback(response.value[rpcmessage_1.RPC_MESSAGE_DELAY].value);
@@ -318,6 +321,7 @@ class WsClient {
                     return;
                 }
                 handler.resolve((() => {
+                    // eslint-disable-next-line unicorn/no-computed-property-existence-check
                     if (rpcmessage_1.RPC_MESSAGE_ERROR in response.value) {
                         const code = response.value[rpcmessage_1.RPC_MESSAGE_ERROR][rpcmessage_1.ERROR_CODE];
                         // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -340,6 +344,7 @@ class WsClient {
                         })();
                         return new ErrorTypeCtor(response.value[rpcmessage_1.RPC_MESSAGE_ERROR]);
                     }
+                    // eslint-disable-next-line unicorn/no-computed-property-existence-check
                     if (rpcmessage_1.RPC_MESSAGE_RESULT in response.value) {
                         return response.value[rpcmessage_1.RPC_MESSAGE_RESULT];
                     }
@@ -353,7 +358,7 @@ class WsClient {
                     }
                 })());
                 // eslint-disable-next-line @typescript-eslint/no-array-delete, @typescript-eslint/no-dynamic-delete
-                delete this.rpcHandlers[Number(requestId)];
+                delete this.rpcHandlers[requestId];
             }
         };
         // eslint-disable-next-line @typescript-eslint/strict-void-return
@@ -383,6 +388,89 @@ class WsClient {
             this.loginProcedure(this.options);
         }
     }
+    workflowsProcedure(options) {
+        let workflowsObtained = false;
+        this.websocket.addEventListener('open', () => {
+            this.options.logDebug('CONNECTED');
+            const handleConnectionError = (error) => {
+                this.logDebug('FAILURE: couldn\'t retrieve workflows', error.message);
+                options.onWorkflowsFailed();
+            };
+            this.callRpcMethod(undefined, 'workflows').then(response => {
+                if (response instanceof Error) {
+                    handleConnectionError(response);
+                    return;
+                }
+                workflowsObtained = true;
+                options.onWorkflows(response);
+                this.close();
+            }).catch(() => {
+                options.onWorkflowsFailed();
+            });
+        });
+        this.websocket.addEventListener('close', () => {
+            this.logDebug('DISCONNECTED');
+            if (!workflowsObtained) {
+                options.onWorkflowsFailed();
+            }
+        });
+    }
+    loginProcedure(options) {
+        this.websocket.addEventListener('open', () => {
+            this.options.logDebug('CONNECTED');
+            const handleConnectionError = (error) => {
+                this.logDebug('FAILURE: couldn\'t perform initial handshake', error.message);
+                options.onConnectionFailure(error);
+            };
+            const handleLoginResponse = (response) => {
+                if (response instanceof Error) {
+                    handleConnectionError(response);
+                    return;
+                }
+                this.logDebug('SUCCESS: connected to shv broker');
+                options.onConnected();
+                this.pingTimerId = setInterval(() => {
+                    this.sendPing();
+                }, options.pingInterval ?? DEFAULT_PING_INTERVAL);
+            };
+            const makeLoginParams = (loginMap) => (0, rpcvalue_1.makeMap)({
+                login: loginMap,
+                options: (0, rpcvalue_1.makeMap)({
+                    device: typeof options.mountPoint === 'string' ? (0, rpcvalue_1.makeMap)({ mountPoint: options.mountPoint }) : undefined,
+                }),
+            });
+            this.callRpcMethod(undefined, 'hello').then(response => {
+                if (response instanceof Error) {
+                    handleConnectionError(response);
+                    return;
+                }
+                const makeLoginMap = () => {
+                    switch (options.login.type) {
+                        case 'PLAIN':
+                            return (0, rpcvalue_1.makeMap)({
+                                password: options.login.password,
+                                type: options.login.type,
+                                user: options.login.user,
+                            });
+                        case 'TOKEN':
+                            return (0, rpcvalue_1.makeMap)({
+                                token: options.login.token,
+                                type: options.login.type,
+                            });
+                    }
+                };
+                return this.callRpcMethod(undefined, 'login', makeLoginParams(makeLoginMap()));
+            }).then(handleLoginResponse).catch(() => {
+                this.logDebug('FAILURE: couldn\' connected to shv broker');
+            });
+        });
+        this.websocket.addEventListener('close', () => {
+            this.logDebug('DISCONNECTED');
+            this.subscriptions.length = 0;
+            options.onDisconnected();
+            clearInterval(this.pingTimerId);
+        });
+    }
     callRpcMethod(shvPath, method, params, options) {
         const rqId = this.requestId++;
         const makeRq = (value) => new rpcvalue_1.RpcValueWithMetaData((0, rpcvalue_1.makeMetaMap)({
@@ -390,7 +478,7 @@ class WsClient {
             [rpcmessage_1.RPC_MESSAGE_REQUEST_ID]: rqId,
             [rpcmessage_1.RPC_MESSAGE_METHOD]: method ?? '',
             [rpcmessage_1.RPC_MESSAGE_SHV_PATH]: shvPath ?? '',
-            ...(options?.requestUserId === true ? { [rpcmessage_1.RPC_MESSAGE_USER_ID]: '' } : {}),
+            ...(options?.requestUserId === true && { [rpcmessage_1.RPC_MESSAGE_USER_ID]: '' }),
         }), value);
         let rq = makeRq((0, rpcvalue_1.makeIMap)({
             [rpcmessage_1.RPC_MESSAGE_PARAMS]: params,
@@ -413,22 +501,23 @@ class WsClient {
         return promise;
     }
     sendRpcMessage(rpcMsg) {
-        if (this.websocket.readyState === WebSocket.OPEN) {
-            this.logDebug('sending rpc message:', (0, cpon_1.toCpon)(rpcMsg));
-            const msgData = new Uint8Array((0, chainpack_1.toChainPack)(rpcMsg));
-            const wr = new chainpack_1.ChainPackWriter();
-            wr.writeUIntData(msgData.length + 1);
-            const dgram = new Uint8Array(wr.ctx.length + 1 + msgData.length);
-            let ix = 0;
-            for (let i = 0; i < wr.ctx.length; i++) {
-                dgram[ix++] = wr.ctx.data[i];
-            }
-            dgram[ix++] = chainpack_1.CHAINPACK_PROTOCOL_TYPE;
-            for (const msgDatum of msgData) {
-                dgram[ix++] = msgDatum;
-            }
-            this.websocket.send(dgram.buffer);
+        if (this.websocket.readyState !== WebSocket.OPEN) {
+            return;
+        }
+        this.logDebug('sending rpc message:', (0, cpon_1.toCpon)(rpcMsg));
+        const msgData = new Uint8Array((0, chainpack_1.toChainPack)(rpcMsg));
+        const wr = new chainpack_1.ChainPackWriter();
+        wr.writeUIntData(msgData.length + 1);
+        const dgram = new Uint8Array(wr.ctx.length + 1 + msgData.length);
+        let ix = 0;
+        for (let i = 0; i < wr.ctx.length; i++) {
+            dgram[ix++] = wr.ctx.data[i];
+        }
+        dgram[ix++] = chainpack_1.CHAINPACK_PROTOCOL_TYPE;
+        for (const msgDatum of msgData) {
+            dgram[ix++] = msgDatum;
         }
+        this.websocket.send(dgram.buffer);
     }
     async getShvApiVersion() {
         if (this.shvApiVersion === undefined) {
@@ -451,11 +540,11 @@ class WsClient {
         const path = ri.path();
         const signal = ri.signal();
         if (this.subscriptions.some(val => val.subscriber === subscriber && val.path === path && val.signal === signal)) {
-            this.logDebug(`Already subscribed {$path}:${signal} for subscriber ${subscriber}`);
+            this.logDebug(`Already subscribed ${path}:${signal} for subscriber ${subscriber}`);
             return;
         }
         // If this path:signal has not been subscribed on the broker, do it now
-        if (!this.subscriptions.some(val => val.path === path && val.signal === signal)) {
+        if (this.subscriptions.every(val => !(val.path === path && val.signal === signal))) {
             switch (await this.getShvApiVersion()) {
                 case ShvApiVersion.V2: {
                     const result = await this.callRpcMethod('.broker/app', 'subscribe', (0, rpcvalue_1.makeMap)({ signal, path }));
@@ -536,88 +625,5 @@ class WsClient {
         }
         this.options.logDebug(...args);
     }
-    workflowsProcedure(options) {
-        let workflowsObtained = false;
-        this.websocket.addEventListener('open', () => {
-            this.options.logDebug('CONNECTED');
-            const handleConnectionError = (error) => {
-                this.logDebug('FAILURE: couldn\'t retrieve workflows', error.message);
-                options.onWorkflowsFailed();
-            };
-            this.callRpcMethod(undefined, 'workflows').then(response => {
-                if (response instanceof Error) {
-                    handleConnectionError(response);
-                    return;
-                }
-                workflowsObtained = true;
-                options.onWorkflows(response);
-                this.close();
-            }).catch(() => {
-                options.onWorkflowsFailed();
-            });
-        });
-        this.websocket.addEventListener('close', () => {
-            this.logDebug('DISCONNECTED');
-            if (!workflowsObtained) {
-                options.onWorkflowsFailed();
-            }
-        });
-    }
-    loginProcedure(options) {
-        this.websocket.addEventListener('open', () => {
-            this.options.logDebug('CONNECTED');
-            const handleConnectionError = (error) => {
-                this.logDebug('FAILURE: couldn\'t perform initial handshake', error.message);
-                options.onConnectionFailure(error);
-            };
-            const handleLoginResponse = (response) => {
-                if (response instanceof Error) {
-                    handleConnectionError(response);
-                    return;
-                }
-                this.logDebug('SUCCESS: connected to shv broker');
-                options.onConnected();
-                this.pingTimerId = globalThis.setInterval(() => {
-                    this.sendPing();
-                }, options.pingInterval ?? DEFAULT_PING_INTERVAL);
-            };
-            const makeLoginParams = (loginMap) => (0, rpcvalue_1.makeMap)({
-                login: loginMap,
-                options: (0, rpcvalue_1.makeMap)({
-                    device: typeof options.mountPoint === 'string' ? (0, rpcvalue_1.makeMap)({ mountPoint: options.mountPoint }) : undefined,
-                }),
-            });
-            this.callRpcMethod(undefined, 'hello').then(response => {
-                if (response instanceof Error) {
-                    handleConnectionError(response);
-                    return;
-                }
-                const makeLoginMap = () => {
-                    switch (options.login.type) {
-                        case 'PLAIN':
-                            return (0, rpcvalue_1.makeMap)({
-                                password: options.login.password,
-                                type: options.login.type,
-                                user: options.login.user,
-                            });
-                        case 'TOKEN':
-                            return (0, rpcvalue_1.makeMap)({
-                                token: options.login.token,
-                                type: options.login.type,
-                            });
-                    }
-                };
-                return this.callRpcMethod(undefined, 'login', makeLoginParams(makeLoginMap()));
-            }).then(handleLoginResponse).catch(() => {
-                this.logDebug('FAILURE: couldn\' connected to shv broker');
-            });
-        });
-        this.websocket.addEventListener('close', () => {
-            this.logDebug('DISCONNECTED');
-            this.subscriptions.length = 0;
-            options.onDisconnected();
-            globalThis.clearInterval(this.pingTimerId);
-        });
-    }
 }
 exports.WsClient = WsClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libshv-js",
-  "version": "7.1.6",
+  "version": "7.1.8",
   "description": "Typescript implementation of libshv",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -40,9 +40,9 @@
     "@typescript-eslint/parser": "^8.56.1",
     "@eslint/js": "^10.0.1",
     "eslint": "^10.0.0",
-    "eslint-config-xo": "^0.52.0",
+    "eslint-config-xo": "^0.55.0",
     "eslint-formatter-unix": "^9.0.1",
-    "eslint-plugin-unicorn": "^66.0.0",
+    "eslint-plugin-unicorn": "^69.0.0",
     "typescript": "^6.0.2",
     "typescript-eslint": "^8.46.1"
   }