libshv-js 7.2.0 → 8.0.1

package/dist/ws-client.js

@@ -1,12 +1,10 @@
-"use strict";
-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.validateDirParam = exports.validateLsParam = 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 utils_1 = require("./utils");
+import { minimatch } from 'minimatch';
+import { accessLevelFromAccessString } from './access.js';
+import { ChainPackReader, CHAINPACK_PROTOCOL_TYPE, ChainPackWriter, toChainPack } from './chainpack.js';
+import { CPON_PROTOCOL_TYPE, toCpon } from './cpon.js';
+import { ERROR_MESSAGE, ErrorCode, ERROR_CODE, isSignal, isRequest, isResponse, ERROR_DATA, RPC_MESSAGE_METHOD, RPC_MESSAGE_SHV_PATH, RPC_MESSAGE_REQUEST_ID, RPC_MESSAGE_PARAMS, RPC_MESSAGE_ERROR, RPC_MESSAGE_RESULT, RPC_MESSAGE_CALLER_IDS, RPC_MESSAGE_DELAY, RPC_MESSAGE_ABORT, RPC_MESSAGE_ACCESS_LEVEL, RPC_MESSAGE_USER_ID } from './rpcmessage.js';
+import { makeMap, makeIMap, RpcValueWithMetaData, makeMetaMap, Double } from './rpcvalue.js';
+import { resolveRI } from './utils.js';
 const DEFAULT_TIMEOUT = 5000;
 const DEFAULT_PING_INTERVAL = 30 * 1000;
 const defaultParseMessage = (rpcVal) => {
@@ -15,13 +13,13 @@ const defaultParseMessage = (rpcVal) => {
     return rpcMsg;
 };
 const dataToRpcValue = (buff) => {
-    const rd = new chainpack_1.ChainPackReader(buff);
+    const rd = new ChainPackReader(buff);
     rd.readUIntData();
     const proto = rd.ctx.getByte();
     switch (proto) {
-        case chainpack_1.CHAINPACK_PROTOCOL_TYPE:
+        case CHAINPACK_PROTOCOL_TYPE:
             break;
-        case cpon_1.CPON_PROTOCOL_TYPE:
+        case CPON_PROTOCOL_TYPE:
             throw new Error('CPON protocol type is not supported anymore');
         default:
             throw new Error(`Unsupported protocol type ${proto}`);
@@ -29,19 +27,16 @@ const dataToRpcValue = (buff) => {
     const rpcVal = rd.read();
     return rpcVal;
 };
-class RequestHandler {
+export class RequestHandler {
     options;
     constructor(options) {
         this.options = options;
         // nothing
     }
 }
-exports.RequestHandler = RequestHandler;
-const validateLsParam = (param) => param === undefined || typeof param === 'string';
-exports.validateLsParam = validateLsParam;
-const validateDirParam = (param) => param === undefined || typeof param === 'string' || typeof param === 'boolean';
-exports.validateDirParam = validateDirParam;
-var DirFlags;
+export const validateLsParam = (param) => param === undefined || typeof param === 'string';
+export const validateDirParam = (param) => param === undefined || typeof param === 'string' || typeof param === 'boolean';
+export var DirFlags;
 (function (DirFlags) {
     DirFlags[DirFlags["Reserved"] = 1] = "Reserved";
     DirFlags[DirFlags["Getter"] = 2] = "Getter";
@@ -49,49 +44,49 @@ var DirFlags;
     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;
+})(DirFlags || (DirFlags = {}));
+export const DIR_NAME = 1;
+export const DIR_FLAGS = 2;
+export const DIR_PARAM = 3;
+export const DIR_RESULT = 4;
+export const DIR_ACCESS = 5;
+export const DIR_SIGNALS = 6;
+export const 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';
+                case ErrorCode.InvalidRequest: return 'InvalidRequest';
+                case ErrorCode.MethodNotFound: return 'MethodNotFound';
+                case ErrorCode.InvalidParams: return 'InvalidParams';
+                case ErrorCode.InternalError: return 'InternalError';
+                case ErrorCode.ParseError: return 'ParseError';
+                case ErrorCode.MethodCallTimeout: return 'MethodCallTimeout';
+                case ErrorCode.MethodCallCancelled: return 'MethodCallCancelled';
+                case ErrorCode.MethodCallException: return 'MethodCallException';
+                case ErrorCode.Unknown: return 'Unknown';
+                case ErrorCode.LoginRequired: return 'LoginRequired';
+                case ErrorCode.UserIDRequired: return 'UserIDRequired';
+                case 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]})`);
+        super(err_info[ERROR_MESSAGE] ?? `${errorCodeToMessage(err_info[ERROR_CODE])} (${err_info[ERROR_CODE]})`);
         this.err_info = err_info;
     }
     data() {
-        return this.err_info[rpcmessage_1.ERROR_DATA];
+        return this.err_info[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,
+    return makeIMap({
+        [ERROR_CODE]: code,
+        [ERROR_MESSAGE]: errInfoOrMsg,
+        [ERROR_DATA]: undefined,
     });
 };
 const createErrorClass = (code) => class extends RpcError {
@@ -100,24 +95,24 @@ const createErrorClass = (code) => class extends RpcError {
     }
 };
 /* eslint-disable @typescript-eslint/naming-convention -- We want class names like this */
-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);
+export const InvalidRequest = createErrorClass(ErrorCode.InvalidRequest);
+export const MethodNotFound = createErrorClass(ErrorCode.MethodNotFound);
+export const InvalidParams = createErrorClass(ErrorCode.InvalidParams);
+export const InternalError = createErrorClass(ErrorCode.InternalError);
+export const ParseError = createErrorClass(ErrorCode.ParseError);
+export const MethodCallTimeout = createErrorClass(ErrorCode.MethodCallTimeout);
+export const MethodCallCancelled = createErrorClass(ErrorCode.MethodCallCancelled);
+export const MethodCallException = createErrorClass(ErrorCode.MethodCallException);
+export const Unknown = createErrorClass(ErrorCode.Unknown);
+export const LoginRequired = createErrorClass(ErrorCode.LoginRequired);
+export const UserIDRequired = createErrorClass(ErrorCode.UserIDRequired);
+export const NotImplemented = createErrorClass(ErrorCode.NotImplemented);
 /* eslint-enable @typescript-eslint/naming-convention */
 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.`,
-        [rpcmessage_1.ERROR_DATA]: undefined,
+    resolve(new MethodCallTimeout(makeIMap({
+        [ERROR_CODE]: ErrorCode.MethodCallTimeout,
+        [ERROR_MESSAGE]: `Shv call timeout after: ${ms} msec.`,
+        [ERROR_DATA]: undefined,
     })));
 }, ms);
 class RpcRequestPromise extends Promise {
@@ -129,11 +124,19 @@ class RpcRequestPromise extends Promise {
         this.progressQuery = progressQuery;
     }
 }
-var ShvApiVersion;
+export var ShvApiVersion;
 (function (ShvApiVersion) {
     ShvApiVersion[ShvApiVersion["V2"] = 0] = "V2";
     ShvApiVersion[ShvApiVersion["V3"] = 1] = "V3";
 })(ShvApiVersion || (ShvApiVersion = {}));
+export const pathMatchesSubscription = (subscriptionPath, signalPath, apiVersion) => {
+    if (apiVersion === ShvApiVersion.V2) {
+        const remainder = signalPath.slice(subscriptionPath.length);
+        return signalPath.startsWith(subscriptionPath) && (remainder.length === 0 || remainder.startsWith('/'));
+    }
+    const recursivePathPrefix = subscriptionPath.endsWith('/**') ? subscriptionPath.slice(0, -3) : undefined;
+    return (recursivePathPrefix !== undefined && minimatch(signalPath, recursivePathPrefix)) || minimatch(signalPath, subscriptionPath);
+};
 class WsClient {
     requestId = 1;
     pingTimerId = undefined;
@@ -153,12 +156,13 @@ class WsClient {
         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) => {
+        const handleSignal = async (signal) => {
+            const apiVersion = await this.getShvApiVersion();
             for (const sub of this.subscriptions) {
-                const shvPath = signal.meta[rpcmessage_1.RPC_MESSAGE_SHV_PATH];
-                const signalName = signal.meta[rpcmessage_1.RPC_MESSAGE_METHOD];
-                if (shvPath.startsWith(sub.path) && signalName === sub.signal) {
-                    sub.callback(shvPath, signalName, signal.value[rpcmessage_1.RPC_MESSAGE_PARAMS]);
+                const shvPath = signal.meta[RPC_MESSAGE_SHV_PATH];
+                const signalName = signal.meta[RPC_MESSAGE_METHOD];
+                if (pathMatchesSubscription(sub.path, shvPath, apiVersion) && signalName === sub.signal) {
+                    sub.callback(shvPath, signalName, signal.value[RPC_MESSAGE_PARAMS]);
                 }
             }
         };
@@ -167,40 +171,40 @@ class WsClient {
             if (!('onRequest' in this.options)) {
                 return;
             }
-            const requestId = request.meta[rpcmessage_1.RPC_MESSAGE_REQUEST_ID];
+            const requestId = request.meta[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,
+                this.sendRpcMessage(new RpcValueWithMetaData(makeMetaMap({
+                    [RPC_MESSAGE_CALLER_IDS]: request.meta[RPC_MESSAGE_CALLER_IDS],
+                    [RPC_MESSAGE_REQUEST_ID]: requestId,
                 }), value));
             };
             const sendDelay = (progress) => {
-                respond((0, rpcvalue_1.makeIMap)({
-                    [rpcmessage_1.RPC_MESSAGE_DELAY]: new rpcvalue_1.Double(progress),
+                respond(makeIMap({
+                    [RPC_MESSAGE_DELAY]: new Double(progress),
                 }));
             };
             // eslint-disable-next-line unicorn/no-computed-property-existence-check
-            if (rpcmessage_1.RPC_MESSAGE_ABORT in request.value) {
+            if (RPC_MESSAGE_ABORT in request.value) {
                 const requestHandler = this.requestHandlers.get(requestId);
-                if (request.value[rpcmessage_1.RPC_MESSAGE_ABORT]) {
+                if (request.value[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) {
+                if (!request.value[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 shvPath = request.meta[RPC_MESSAGE_SHV_PATH];
+                const methodName = request.meta[RPC_MESSAGE_METHOD];
                 const unhandledMethod = () => {
-                    throw new exports.MethodNotFound(`No such path '${shvPath}' or method '${methodName}' or insufficient access rights.`);
+                    throw new MethodNotFound(`No such path '${shvPath}' or method '${methodName}' or insufficient access rights.`);
                 };
-                const accessLevel = request.meta[rpcmessage_1.RPC_MESSAGE_ACCESS_LEVEL];
+                const accessLevel = request.meta[RPC_MESSAGE_ACCESS_LEVEL];
                 if (accessLevel === undefined) {
                     unhandledMethod();
                     return;
@@ -211,34 +215,34 @@ class WsClient {
                     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 dirEntry = makeIMap({
+                        [DIR_NAME]: 'dir',
+                        [DIR_FLAGS]: 0,
+                        [DIR_PARAM]: 'DirParam',
+                        [DIR_RESULT]: 'DirResult',
+                        [DIR_ACCESS]: accessLevelFromAccessString('bws'),
+                        [DIR_SIGNALS]: makeMap({}),
+                        [DIR_EXTRA]: 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)({}),
+                    const lsEntry = makeIMap({
+                        [DIR_NAME]: 'ls',
+                        [DIR_FLAGS]: 0,
+                        [DIR_PARAM]: 'LsParam',
+                        [DIR_RESULT]: 'LsResult',
+                        [DIR_ACCESS]: accessLevelFromAccessString('bws'),
+                        [DIR_SIGNALS]: makeMap({}),
+                        [DIR_EXTRA]: makeMap({}),
                     });
                     switch (methodName) {
                         case 'dir':
                             return {
                                 entry: dirEntry,
-                                paramValidator: exports.validateDirParam,
+                                paramValidator: 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;
+                                            return methodsResult.find(method => method[DIR_NAME] === param) ?? false;
                                         case typeof param === 'boolean':
                                         case param === undefined:
                                             console.log('methodsResult', '=', methodsResult);
@@ -249,34 +253,34 @@ class WsClient {
                         case 'ls':
                             return {
                                 entry: lsEntry,
-                                paramValidator: exports.validateLsParam,
+                                paramValidator: validateLsParam,
                                 handler(shvPath) {
                                     return methods.ls(shvPath);
                                 },
                             };
                         default:
-                            return methods.dirEntries.find(method => method.entry[exports.DIR_NAME] === methodName);
+                            return methods.dirEntries.find(method => method.entry[DIR_NAME] === methodName);
                     }
                 })();
                 if (methodDefinition === undefined) {
                     unhandledMethod();
                     return;
                 }
-                if (accessLevel < methodDefinition.entry[exports.DIR_ACCESS]) {
+                if (accessLevel < methodDefinition.entry[DIR_ACCESS]) {
                     unhandledMethod();
                     return;
                 }
-                const requestParam = request.value[rpcmessage_1.RPC_MESSAGE_PARAMS];
+                const requestParam = request.value[RPC_MESSAGE_PARAMS];
                 if (methodDefinition.paramValidator !== undefined && !methodDefinition.paramValidator(requestParam)) {
-                    throw new exports.InvalidParams(`Unexpected param '${shvPath}:${methodName}': ${(0, cpon_1.toCpon)(requestParam)}`);
+                    throw new InvalidParams(`Unexpected param '${shvPath}:${methodName}': ${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,
+                const resultOrError = makeIMap({
+                    [RPC_MESSAGE_RESULT]: result instanceof Promise ? await result : result,
                 });
                 if (!this.abortedRequests.has(requestId)) {
                     respond(resultOrError);
@@ -290,8 +294,8 @@ class WsClient {
             }
             catch (error) {
                 const sendError = (error) => {
-                    respond((0, rpcvalue_1.makeIMap)({
-                        [rpcmessage_1.RPC_MESSAGE_ERROR]: error.err_info,
+                    respond(makeIMap({
+                        [RPC_MESSAGE_ERROR]: error.err_info,
                     }));
                 };
                 switch (true) {
@@ -299,54 +303,54 @@ class WsClient {
                         sendError(error);
                         break;
                     case error instanceof Error:
-                        sendError(new exports.InternalError(error.message));
+                        sendError(new InternalError(error.message));
                         break;
                     default:
-                        sendError(new exports.InternalError('Unknown error'));
+                        sendError(new InternalError('Unknown error'));
                         break;
                 }
             }
         };
         const handleResponse = (response) => {
-            const requestId = response.meta[rpcmessage_1.RPC_MESSAGE_REQUEST_ID];
+            const requestId = response.meta[RPC_MESSAGE_REQUEST_ID];
             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 (RPC_MESSAGE_DELAY in response.value) {
                     if (handler.delayCallback !== undefined) {
-                        handler.delayCallback(response.value[rpcmessage_1.RPC_MESSAGE_DELAY].value);
+                        handler.delayCallback(response.value[RPC_MESSAGE_DELAY].value);
                     }
                     handler.timeout_handle = makeTimeout(this.timeout, handler.resolve);
                     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];
+                    if (RPC_MESSAGE_ERROR in response.value) {
+                        const code = response.value[RPC_MESSAGE_ERROR][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;
+                                case ErrorCode.InvalidRequest: return InvalidRequest;
+                                case ErrorCode.MethodNotFound: return MethodNotFound;
+                                case ErrorCode.InvalidParams: return InvalidParams;
+                                case ErrorCode.InternalError: return InternalError;
+                                case ErrorCode.ParseError: return ParseError;
+                                case ErrorCode.MethodCallTimeout: return MethodCallTimeout;
+                                case ErrorCode.MethodCallCancelled: return MethodCallCancelled;
+                                case ErrorCode.MethodCallException: return MethodCallException;
+                                case ErrorCode.Unknown: return Unknown;
+                                case ErrorCode.LoginRequired: return LoginRequired;
+                                case ErrorCode.UserIDRequired: return UserIDRequired;
+                                case ErrorCode.NotImplemented: return NotImplemented;
+                                default: return Unknown;
                             }
                         })();
-                        return new ErrorTypeCtor(response.value[rpcmessage_1.RPC_MESSAGE_ERROR]);
+                        return new ErrorTypeCtor(response.value[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];
+                    if (RPC_MESSAGE_RESULT in response.value) {
+                        return response.value[RPC_MESSAGE_RESULT];
                     }
                     // At this point, the RpcResponse either has:
                     // - no keys, which means that the response has an implicit Null result.
@@ -354,7 +358,7 @@ class WsClient {
                     // 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(' ')}`);
+                        return new NotImplemented(`Got an RpcResponse with unsupported keys: ${rpcMessageKeys.join(' ')}`);
                     }
                 })());
                 // eslint-disable-next-line @typescript-eslint/no-array-delete, @typescript-eslint/no-dynamic-delete
@@ -366,14 +370,14 @@ class WsClient {
             const rpcVal = dataToRpcValue(evt.data);
             const parseMessage = this.options.parseMessage ?? defaultParseMessage;
             const rpcMsg = parseMessage(rpcVal);
-            this.logDebug(`message received: ${(0, cpon_1.toCpon)(rpcMsg)}`);
-            if ((0, rpcmessage_1.isSignal)(rpcMsg)) {
-                handleSignal(rpcMsg);
+            this.logDebug(`message received: ${toCpon(rpcMsg)}`);
+            if (isSignal(rpcMsg)) {
+                await handleSignal(rpcMsg);
             }
-            else if ((0, rpcmessage_1.isRequest)(rpcMsg)) {
+            else if (isRequest(rpcMsg)) {
                 await handleRequest(rpcMsg);
             }
-            else if ((0, rpcmessage_1.isResponse)(rpcMsg)) {
+            else if (isResponse(rpcMsg)) {
                 handleResponse(rpcMsg);
             }
         });
@@ -433,10 +437,10 @@ class WsClient {
                     this.sendPing();
                 }, options.pingInterval ?? DEFAULT_PING_INTERVAL);
             };
-            const makeLoginParams = (loginMap) => (0, rpcvalue_1.makeMap)({
+            const makeLoginParams = (loginMap) => makeMap({
                 login: loginMap,
-                options: (0, rpcvalue_1.makeMap)({
-                    device: typeof options.mountPoint === 'string' ? (0, rpcvalue_1.makeMap)({ mountPoint: options.mountPoint }) : undefined,
+                options: makeMap({
+                    device: typeof options.mountPoint === 'string' ? makeMap({ mountPoint: options.mountPoint }) : undefined,
                 }),
             });
             this.callRpcMethod(undefined, 'hello').then(response => {
@@ -447,13 +451,13 @@ class WsClient {
                 const makeLoginMap = () => {
                     switch (options.login.type) {
                         case 'PLAIN':
-                            return (0, rpcvalue_1.makeMap)({
+                            return makeMap({
                                 password: options.login.password,
                                 type: options.login.type,
                                 user: options.login.user,
                             });
                         case 'TOKEN':
-                            return (0, rpcvalue_1.makeMap)({
+                            return makeMap({
                                 token: options.login.token,
                                 type: options.login.type,
                             });
@@ -473,19 +477,19 @@ class WsClient {
     }
     callRpcMethod(shvPath, method, params, options) {
         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 ?? '',
-            ...(options?.requestUserId === true && { [rpcmessage_1.RPC_MESSAGE_USER_ID]: '' }),
+        const makeRq = (value) => new RpcValueWithMetaData(makeMetaMap({
+            [RPC_MESSAGE_CALLER_IDS]: undefined,
+            [RPC_MESSAGE_REQUEST_ID]: rqId,
+            [RPC_MESSAGE_METHOD]: method ?? '',
+            [RPC_MESSAGE_SHV_PATH]: shvPath ?? '',
+            ...(options?.requestUserId === true && { [RPC_MESSAGE_USER_ID]: '' }),
         }), value);
         // We will not add an explicit null as a param unless the user requests it. Receivers of RpcCalls should
         // generally handle a missing param the same as if the param was Null.
         const paramRaw = params !== undefined || (options?.explicitNullParam ?? false) ? {
-            [rpcmessage_1.RPC_MESSAGE_PARAMS]: params,
+            [RPC_MESSAGE_PARAMS]: params,
         } : {};
-        let rq = makeRq((0, rpcvalue_1.makeIMap)(paramRaw));
+        let rq = makeRq(makeIMap(paramRaw));
         if (options?.beforeSendHook !== undefined) {
             rq = options.beforeSendHook(rq);
         }
@@ -493,12 +497,12 @@ class WsClient {
         const promise = new RpcRequestPromise(resolve => {
             this.rpcHandlers[rqId] = { resolve, timeout_handle: makeTimeout(this.timeout, resolve), delayCallback: options?.delayCallback };
         }, () => {
-            this.sendRpcMessage(makeRq((0, rpcvalue_1.makeIMap)({
-                [rpcmessage_1.RPC_MESSAGE_ABORT]: true,
+            this.sendRpcMessage(makeRq(makeIMap({
+                [RPC_MESSAGE_ABORT]: true,
             })));
         }, () => {
-            this.sendRpcMessage(makeRq((0, rpcvalue_1.makeIMap)({
-                [rpcmessage_1.RPC_MESSAGE_ABORT]: false,
+            this.sendRpcMessage(makeRq(makeIMap({
+                [RPC_MESSAGE_ABORT]: false,
             })));
         });
         return promise;
@@ -507,16 +511,16 @@ class WsClient {
         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();
+        this.logDebug('sending rpc message:', toCpon(rpcMsg));
+        const msgData = new Uint8Array(toChainPack(rpcMsg));
+        const wr = new 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;
+        dgram[ix++] = CHAINPACK_PROTOCOL_TYPE;
         for (const msgDatum of msgData) {
             dgram[ix++] = msgDatum;
         }
@@ -539,7 +543,7 @@ class WsClient {
         return this.shvApiVersion;
     }
     async subscribe(subscriber, riGetter, callback) {
-        const ri = await (0, utils_1.resolveRI)(riGetter);
+        const ri = await resolveRI(riGetter);
         const path = ri.path();
         const signal = ri.signal();
         if (this.subscriptions.some(val => val.subscriber === subscriber && val.path === path && val.signal === signal)) {
@@ -550,7 +554,7 @@ class WsClient {
         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 }));
+                    const result = await this.callRpcMethod('.broker/app', 'subscribe', makeMap({ signal, path }));
                     if (result instanceof Error) {
                         this.logDebug(`Couldn't subscribe to ${path}, ${signal}`);
                     }
@@ -578,7 +582,7 @@ class WsClient {
         });
     }
     async unsubscribe(subscriber, riGetter) {
-        const ri = await (0, utils_1.resolveRI)(riGetter);
+        const ri = await resolveRI(riGetter);
         const path = ri.path();
         const signal = ri.signal();
         const idx = this.subscriptions.findIndex(val => val.subscriber === subscriber && val.path === path && val.signal === signal);
@@ -593,14 +597,14 @@ class WsClient {
         }
         switch (await this.getShvApiVersion()) {
             case ShvApiVersion.V2: {
-                const result = await this.callRpcMethod('.broker/app', 'unsubscribe', (0, rpcvalue_1.makeMap)({ signal, path }));
+                const result = await this.callRpcMethod('.broker/app', 'unsubscribe', makeMap({ signal, path }));
                 if (result instanceof Error) {
                     this.logDebug(`Couldn't unsubscribe ${path}, ${signal}`);
                 }
                 break;
             }
             case ShvApiVersion.V3: {
-                const result = await this.callRpcMethod('.broker/currentClient', 'unsubscribe', (0, rpcvalue_1.makeMap)({ ri: ri.asString(), ttl: undefined }));
+                const result = await this.callRpcMethod('.broker/currentClient', 'unsubscribe', makeMap({ ri: ri.asString(), ttl: undefined }));
                 if (result instanceof Error) {
                     this.logDebug(`Couldn't unsubscribe ${path}, ${signal}`);
                 }
@@ -629,4 +633,4 @@ class WsClient {
         this.options.logDebug(...args);
     }
 }
-exports.WsClient = WsClient;
+export { WsClient };

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "libshv-js",
-  "version": "7.2.0",
+  "version": "8.0.1",
   "description": "Typescript implementation of libshv",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "type": "module",
   "files": [
     "dist"
   ],
@@ -45,5 +46,8 @@
     "eslint-plugin-unicorn": "^73.0.0",
     "typescript": "^6.0.2",
     "typescript-eslint": "^8.46.1"
+  },
+  "dependencies": {
+    "minimatch": "^10.2.6"
   }
 }