libshv-js 3.16.1 → 3.20.0

package/dist/ws-client.js

@@ -0,0 +1,586 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsClient = exports.NotImplemented = exports.UserIDRequired = exports.LoginRequired = exports.Unknown = exports.MethodCallException = exports.MethodCallCancelled = exports.MethodCallTimeout = exports.ParseError = exports.InternalError = exports.InvalidParams = exports.MethodNotFound = exports.InvalidRequest = exports.DIR_EXTRA = exports.DIR_SIGNALS = exports.DIR_ACCESS = exports.DIR_RESULT = exports.DIR_PARAM = exports.DIR_FLAGS = exports.DIR_NAME = exports.DirFlags = exports.DirParamZod = exports.LsParamZod = exports.RequestHandler = void 0;
+const access_1 = require("./access");
+const chainpack_1 = require("./chainpack");
+const cpon_1 = require("./cpon");
+const rpcmessage_1 = require("./rpcmessage");
+const rpcvalue_1 = require("./rpcvalue");
+const z = __importStar(require("./zod"));
+const DEFAULT_TIMEOUT = 5000;
+const DEFAULT_PING_INTERVAL = 30 * 1000;
+const dataToRpcValue = (buff) => {
+    const rd = new chainpack_1.ChainPackReader(buff);
+    rd.readUIntData();
+    const proto = rd.ctx.getByte();
+    switch (proto) {
+        case chainpack_1.CHAINPACK_PROTOCOL_TYPE:
+            break;
+        case cpon_1.CPON_PROTOCOL_TYPE:
+            throw new Error('CPON protocol type is not supported anymore');
+        default:
+            throw new Error(`Unsupported protocol type ${proto}`);
+    }
+    const rpcVal = rd.read();
+    return rpcVal;
+};
+class RequestHandler {
+    options;
+    constructor(options) {
+        this.options = options;
+        /* nothing */
+    }
+}
+exports.RequestHandler = RequestHandler;
+exports.LsParamZod = z.undefined().or(z.string());
+exports.DirParamZod = z.undefined().or(z.boolean()).or(z.string());
+var DirFlags;
+(function (DirFlags) {
+    DirFlags[DirFlags["Reserved"] = 1] = "Reserved";
+    DirFlags[DirFlags["Getter"] = 2] = "Getter";
+    DirFlags[DirFlags["Setter"] = 4] = "Setter";
+    DirFlags[DirFlags["LargeResultHint"] = 8] = "LargeResultHint";
+    DirFlags[DirFlags["NotIdempotent"] = 16] = "NotIdempotent";
+    DirFlags[DirFlags["RequiresClientId"] = 32] = "RequiresClientId";
+})(DirFlags || (exports.DirFlags = DirFlags = {}));
+exports.DIR_NAME = 1;
+exports.DIR_FLAGS = 2;
+exports.DIR_PARAM = 3;
+exports.DIR_RESULT = 4;
+exports.DIR_ACCESS = 5;
+exports.DIR_SIGNALS = 6;
+exports.DIR_EXTRA = 63;
+class RpcError extends Error {
+    err_info;
+    constructor(err_info) {
+        const errorCodeToMessage = (code) => {
+            switch (code) {
+                case rpcmessage_1.ErrorCode.InvalidRequest: return 'InvalidRequest';
+                case rpcmessage_1.ErrorCode.MethodNotFound: return 'MethodNotFound';
+                case rpcmessage_1.ErrorCode.InvalidParams: return 'InvalidParams';
+                case rpcmessage_1.ErrorCode.InternalError: return 'InternalError';
+                case rpcmessage_1.ErrorCode.ParseError: return 'ParseError';
+                case rpcmessage_1.ErrorCode.MethodCallTimeout: return 'MethodCallTimeout';
+                case rpcmessage_1.ErrorCode.MethodCallCancelled: return 'MethodCallCancelled';
+                case rpcmessage_1.ErrorCode.MethodCallException: return 'MethodCallException';
+                case rpcmessage_1.ErrorCode.Unknown: return 'Unknown';
+                case rpcmessage_1.ErrorCode.LoginRequired: return 'LoginRequired';
+                case rpcmessage_1.ErrorCode.UserIDRequired: return 'UserIDRequired';
+                case rpcmessage_1.ErrorCode.NotImplemented: return 'NotImplemented';
+                default: return 'Unknown RpcError';
+            }
+        };
+        super(err_info[rpcmessage_1.ERROR_MESSAGE] ?? `${errorCodeToMessage(err_info[rpcmessage_1.ERROR_CODE])} (${err_info[rpcmessage_1.ERROR_CODE]})`);
+        this.err_info = err_info;
+    }
+    data() {
+        return this.err_info[rpcmessage_1.ERROR_DATA];
+    }
+}
+const makeErrInfo = (errInfoOrMsg, code) => {
+    if (typeof errInfoOrMsg === 'object') {
+        return errInfoOrMsg;
+    }
+    return (0, rpcvalue_1.makeIMap)({
+        [rpcmessage_1.ERROR_CODE]: code,
+        [rpcmessage_1.ERROR_MESSAGE]: errInfoOrMsg,
+        [rpcmessage_1.ERROR_DATA]: undefined,
+    });
+};
+const createErrorClass = (code) => class extends RpcError {
+    constructor(errInfoOrMsg) {
+        super(makeErrInfo(errInfoOrMsg, code));
+    }
+};
+/* eslint-disable @typescript-eslint/naming-convention */
+exports.InvalidRequest = createErrorClass(rpcmessage_1.ErrorCode.InvalidRequest);
+exports.MethodNotFound = createErrorClass(rpcmessage_1.ErrorCode.MethodNotFound);
+exports.InvalidParams = createErrorClass(rpcmessage_1.ErrorCode.InvalidParams);
+exports.InternalError = createErrorClass(rpcmessage_1.ErrorCode.InternalError);
+exports.ParseError = createErrorClass(rpcmessage_1.ErrorCode.ParseError);
+exports.MethodCallTimeout = createErrorClass(rpcmessage_1.ErrorCode.MethodCallTimeout);
+exports.MethodCallCancelled = createErrorClass(rpcmessage_1.ErrorCode.MethodCallCancelled);
+exports.MethodCallException = createErrorClass(rpcmessage_1.ErrorCode.MethodCallException);
+exports.Unknown = createErrorClass(rpcmessage_1.ErrorCode.Unknown);
+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(() => {
+    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.`,
+        [rpcmessage_1.ERROR_DATA]: undefined,
+    })));
+}, ms);
+class RpcRequestPromise extends Promise {
+    abort;
+    progressQuery;
+    constructor(executor, abort, progressQuery) {
+        super(executor);
+        this.abort = abort;
+        this.progressQuery = progressQuery;
+    }
+}
+class WsClient {
+    requestId = 1;
+    pingTimerId = undefined;
+    rpcHandlers = [];
+    requestHandlers = new Map();
+    abortedRequests = new Set();
+    subscriptions = [];
+    websocket;
+    options;
+    timeout;
+    constructor(options) {
+        if (typeof options !== 'object') {
+            throw new TypeError('No options object supplied');
+        }
+        this.options = options;
+        this.timeout = 'timeout' in options && options.timeout !== undefined ? options.timeout : DEFAULT_TIMEOUT;
+        this.websocket = new WebSocket(options.wsUri);
+        this.websocket.binaryType = 'arraybuffer';
+        const handleSignal = (signal) => {
+            for (const sub of this.subscriptions) {
+                const shvPath = signal.meta[rpcmessage_1.RPC_MESSAGE_SHV_PATH];
+                const method = signal.meta[rpcmessage_1.RPC_MESSAGE_METHOD];
+                if (shvPath.startsWith(sub.path) && method === sub.method) {
+                    sub.callback(shvPath, method, signal.value[rpcmessage_1.RPC_MESSAGE_PARAMS]);
+                }
+            }
+        };
+        // 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] === true) {
+                        this.abortedRequests.add(requestId);
+                        if (requestHandler?.options.onAbort !== undefined) {
+                            requestHandler.options.onAbort();
+                        }
+                    }
+                    if (request.value[rpcmessage_1.RPC_MESSAGE_ABORT] === false && 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;
+                    }
+                    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,
+                                    paramParser: exports.DirParamZod,
+                                    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,
+                                    paramParser: exports.LsParamZod,
+                                    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];
+                    const parsedParam = methodDefinition.paramParser.safeParse(requestParam);
+                    if (!parsedParam.success) {
+                        throw new exports.InvalidParams(`Unexpected param for method ${methodName} on path '${shvPath}': ${(0, cpon_1.toCpon)(requestParam)}`);
+                    }
+                    let result = methodDefinition.handler(shvPath, methodName, parsedParam.data, 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);
+                    }
+                }
+                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)];
+                clearTimeout(handler.timeout_handle);
+                if (rpcmessage_1.RPC_MESSAGE_DELAY in response.value) {
+                    if (handler.delayCallback !== undefined) {
+                        handler.delayCallback(response.value[rpcmessage_1.RPC_MESSAGE_DELAY].value);
+                    }
+                    handler.timeout_handle = makeTimeout(this.timeout, handler.resolve);
+                    return;
+                }
+                handler.resolve((() => {
+                    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
+                        const ErrorTypeCtor = (() => {
+                            switch (code) {
+                                case rpcmessage_1.ErrorCode.InvalidRequest: return exports.InvalidRequest;
+                                case rpcmessage_1.ErrorCode.MethodNotFound: return exports.MethodNotFound;
+                                case rpcmessage_1.ErrorCode.InvalidParams: return exports.InvalidParams;
+                                case rpcmessage_1.ErrorCode.InternalError: return exports.InternalError;
+                                case rpcmessage_1.ErrorCode.ParseError: return exports.ParseError;
+                                case rpcmessage_1.ErrorCode.MethodCallTimeout: return exports.MethodCallTimeout;
+                                case rpcmessage_1.ErrorCode.MethodCallCancelled: return exports.MethodCallCancelled;
+                                case rpcmessage_1.ErrorCode.MethodCallException: return exports.MethodCallException;
+                                case rpcmessage_1.ErrorCode.Unknown: return exports.Unknown;
+                                case rpcmessage_1.ErrorCode.LoginRequired: return exports.LoginRequired;
+                                case rpcmessage_1.ErrorCode.UserIDRequired: return exports.UserIDRequired;
+                                case rpcmessage_1.ErrorCode.NotImplemented: return exports.NotImplemented;
+                                default: return exports.Unknown;
+                            }
+                        })();
+                        return new ErrorTypeCtor(response.value[rpcmessage_1.RPC_MESSAGE_ERROR]);
+                    }
+                    if (rpcmessage_1.RPC_MESSAGE_RESULT in response.value) {
+                        return response.value[rpcmessage_1.RPC_MESSAGE_RESULT];
+                    }
+                    // At this point, the RpcResponse either has:
+                    // - no keys, which means that the response has an implicit Null result.
+                    // - has some unknown keys, in which case we will produce an error for the client.
+                    // https://silicon-heaven.github.io/shv-doc/rpcmessage.html#response
+                    const rpcMessageKeys = Object.keys(response.value);
+                    if (rpcMessageKeys.length !== 0) {
+                        return new exports.NotImplemented(`Got an RpcResponse with unsupported keys: ${rpcMessageKeys.join(' ')}`);
+                    }
+                })());
+                // eslint-disable-next-line @typescript-eslint/no-array-delete
+                delete this.rpcHandlers[Number(requestId)];
+            }
+        };
+        this.websocket.addEventListener('message', async (evt) => {
+            const rpcVal = dataToRpcValue(evt.data);
+            const rpcMsg = rpcmessage_1.RpcMessageZod.parse(rpcVal);
+            this.logDebug(`message received: ${(0, cpon_1.toCpon)(rpcMsg)}`);
+            if ((0, rpcmessage_1.isSignal)(rpcMsg)) {
+                handleSignal(rpcMsg);
+            }
+            else if ((0, rpcmessage_1.isRequest)(rpcMsg)) {
+                await handleRequest(rpcMsg);
+            }
+            else if ((0, rpcmessage_1.isResponse)(rpcMsg)) {
+                handleResponse(rpcMsg);
+            }
+        });
+        this.websocket.addEventListener('error', evt => {
+            console.log('WebSocket ERROR', evt);
+            this.logDebug('WebSocket ERROR');
+        });
+        if ('onWorkflows' in this.options) {
+            this.workflowsProcedure(this.options);
+        }
+        else {
+            this.loginProcedure(this.options);
+        }
+    }
+    callRpcMethod(shvPath, method, params, delayCallback) {
+        const rqId = this.requestId++;
+        const makeRq = (value) => new rpcvalue_1.RpcValueWithMetaData((0, rpcvalue_1.makeMetaMap)({
+            [rpcmessage_1.RPC_MESSAGE_CALLER_IDS]: undefined,
+            [rpcmessage_1.RPC_MESSAGE_REQUEST_ID]: rqId,
+            [rpcmessage_1.RPC_MESSAGE_METHOD]: method ?? '',
+            [rpcmessage_1.RPC_MESSAGE_SHV_PATH]: shvPath ?? '',
+        }), value);
+        const rq = makeRq((0, rpcvalue_1.makeIMap)({
+            [rpcmessage_1.RPC_MESSAGE_PARAMS]: params,
+        }));
+        this.sendRpcMessage(rq);
+        const promise = new RpcRequestPromise(resolve => {
+            this.rpcHandlers[rqId] = { resolve, timeout_handle: makeTimeout(this.timeout, resolve), delayCallback };
+        }, () => {
+            this.sendRpcMessage(makeRq((0, rpcvalue_1.makeIMap)({
+                [rpcmessage_1.RPC_MESSAGE_ABORT]: true,
+            })));
+        }, () => {
+            this.sendRpcMessage(makeRq((0, rpcvalue_1.makeIMap)({
+                [rpcmessage_1.RPC_MESSAGE_ABORT]: false,
+            })));
+        });
+        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);
+        }
+    }
+    subscribe(subscriber, path, method, callback) {
+        if (this.subscriptions.some(val => val.subscriber === subscriber && val.path === path && val.method === method)) {
+            this.logDebug(`Already subscribed {$path}:${method} for subscriber ${subscriber}`);
+            return;
+        }
+        // If this path:method has not been subscribed on the broker, do it now
+        if (!this.subscriptions.some(val => val.path === path && val.method === method)) {
+            this.callRpcMethod('.broker/app', 'subscribe', (0, rpcvalue_1.makeMap)({
+                method, path,
+            })).catch(() => {
+                this.logDebug(`Couldn't subscribe to ${path}, ${method}`);
+            });
+        }
+        this.subscriptions.push({
+            subscriber,
+            path,
+            method,
+            callback,
+        });
+    }
+    unsubscribe(subscriber, path, method) {
+        const idx = this.subscriptions.findIndex(val => val.subscriber === subscriber && val.path === path && val.method === method);
+        if (idx === -1) {
+            this.logDebug(`No such subscription ${path}:${method} for subscriber ${subscriber}`);
+            return;
+        }
+        this.subscriptions.splice(idx, 1);
+        // Unsubscribe on the broker only if there are no other subscriptions of this path:method
+        if (this.subscriptions.some(val => val.path === path && val.method === method)) {
+            return;
+        }
+        this.callRpcMethod('.broker/app', 'unsubscribe', (0, rpcvalue_1.makeMap)({
+            method, path,
+        })).catch(() => {
+            this.logDebug(`Couldn't unsubscribe ${path}, ${method}`);
+        });
+    }
+    sendPing() {
+        this.callRpcMethod('.broker/app', 'ping').catch((error) => {
+            console.log('Failed to send ping:', error);
+        });
+    }
+    accessGrantForMethodCall(path, method) {
+        return this.callRpcMethod('.broker/currentClient', 'accessGrantForMethodCall', [path, method]);
+    }
+    close() {
+        this.websocket.close();
+    }
+    logDebug(...args) {
+        if (this.options.logDebug === undefined) {
+            return;
+        }
+        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/dist/zod.d.ts

@@ -0,0 +1,30 @@
+import { z, type ZodType } from 'zod/v4';
+import { Decimal, Double, type MetaMap, RpcValue, type RpcValueType, RpcValueWithMetaData, shvMapType, UInt } from './rpcvalue';
+export declare const map: <T extends Record<string, ZodType<any>>>(schema: T) => z.ZodCustom<z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> & {
+    [shvMapType]: "map";
+}, z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> & {
+    [shvMapType]: "map";
+}>;
+export declare const imap: <T extends Record<number, ZodType<any>>>(schema: T) => z.ZodCustom<z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> & {
+    [shvMapType]: "imap";
+}, z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> & {
+    [shvMapType]: "imap";
+}>;
+export declare const metamap: <T extends Record<string | number, ZodType<any>>>(schema: T) => z.ZodCustom<z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> & {
+    [shvMapType]: "metamap";
+}, z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> & {
+    [shvMapType]: "metamap";
+}>;
+export declare const recmap: <T extends ZodType<any>>(schema: T) => z.ZodCustom<Record<any, z.core.output<T>> & {
+    [shvMapType]: "map";
+}, Record<any, z.core.output<T>> & {
+    [shvMapType]: "map";
+}>;
+export declare const uint: () => z.ZodCustom<UInt<number>, UInt<number>>;
+export declare const double: () => z.ZodCustom<Double, Double>;
+export declare const decimal: () => z.ZodCustom<Decimal, Decimal>;
+export declare const blob: () => z.ZodCustom<ArrayBuffer, ArrayBuffer>;
+export declare const list: () => z.ZodArray<z.ZodLazy<z.ZodType<RpcValue>>>;
+export declare const rpcvalue: () => ZodType<RpcValue>;
+export declare const withMeta: <MetaSchema extends MetaMap, ValueSchema extends RpcValueType>(metaParser: ZodType<MetaSchema>, valueParser: ZodType<ValueSchema>) => z.ZodCustom<RpcValueWithMetaData<MetaSchema, ValueSchema>, RpcValueWithMetaData<MetaSchema, ValueSchema>>;
+export * from 'zod/v4';