libshv-js 6.0.0 → 7.0.1

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export * from './cpon';
 export * from './json';
 export * from './rpcmessage';
 export * from './rpcvalue';
+export * from './shv-ri';
 export * from './ws-client';

package/dist/index.js

@@ -21,4 +21,5 @@ __exportStar(require("./cpon"), exports);
 __exportStar(require("./json"), exports);
 __exportStar(require("./rpcmessage"), exports);
 __exportStar(require("./rpcvalue"), exports);
+__exportStar(require("./shv-ri"), exports);
 __exportStar(require("./ws-client"), exports);

package/dist/shv-ri.d.ts

@@ -0,0 +1,12 @@
+export declare class ShvRI {
+    private ri;
+    private methodSepIx;
+    private signalSepIx?;
+    constructor(ri: string);
+    path(): string;
+    method(): string;
+    signal(): string | undefined;
+    hasSignal(): boolean;
+    asString(): string;
+    static fromPathMethodSignal(path: string, method: string, signal?: string): ShvRI;
+}

package/dist/shv-ri.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShvRI = void 0;
+class ShvRI {
+    ri;
+    methodSepIx;
+    signalSepIx;
+    constructor(ri) {
+        const methodSepIx = ri.indexOf(':');
+        if (methodSepIx === -1) {
+            throw new Error('Method separator ":" is missing.');
+        }
+        const signalSepRelative = ri.indexOf(':', methodSepIx + 1);
+        const signalSepIx = signalSepRelative !== -1 ? signalSepRelative : undefined;
+        this.ri = ri;
+        this.methodSepIx = methodSepIx;
+        this.signalSepIx = signalSepIx;
+        const method = this.method();
+        if (method.length === 0) {
+            throw new Error('Method must not be empty.');
+        }
+        const signal = this.signal();
+        if (signal?.length === 0) {
+            throw new Error('Signal, if present, must not be empty.');
+        }
+    }
+    path() {
+        return this.ri.slice(0, this.methodSepIx);
+    }
+    method() {
+        if (this.signalSepIx !== undefined) {
+            return this.ri.slice(this.methodSepIx + 1, this.signalSepIx);
+        }
+        return this.ri.slice(this.methodSepIx + 1);
+    }
+    signal() {
+        if (this.signalSepIx !== undefined) {
+            return this.ri.slice(this.signalSepIx + 1);
+        }
+    }
+    hasSignal() {
+        return this.signalSepIx !== undefined;
+    }
+    asString() {
+        return this.ri;
+    }
+    static fromPathMethodSignal(path, method, signal) {
+        const m = method.length === 0 ? '*' : method;
+        const ri = signal !== undefined
+            ? `${path}:${m}:${signal}`
+            : `${path}:${m}`;
+        return new ShvRI(ri);
+    }
+}
+exports.ShvRI = ShvRI;

package/dist/utils.d.ts

@@ -1,2 +1,5 @@
+import { ShvRI } from './shv-ri';
 export type StringGetter = string | Promise<string> | (() => string | Promise<string>);
 export declare const resolveString: (input: StringGetter) => string | Promise<string>;
+export type RIGetter = ShvRI | Promise<ShvRI> | (() => ShvRI | Promise<ShvRI>);
+export declare const resolveRI: (input: RIGetter) => ShvRI | Promise<ShvRI>;

package/dist/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveString = void 0;
+exports.resolveRI = exports.resolveString = void 0;
 const resolveString = (input) => {
     if (typeof input === 'function') {
         input = input();
@@ -8,3 +8,10 @@ const resolveString = (input) => {
     return input;
 };
 exports.resolveString = resolveString;
+const resolveRI = (input) => {
+    if (typeof input === 'function') {
+        input = input();
+    }
+    return input;
+};
+exports.resolveRI = resolveRI;

package/dist/ws-client.d.ts

@@ -1,7 +1,7 @@
 import { type RpcMessage, type ErrorMap } from './rpcmessage';
 import { type RpcValue, type Null, type Int, type IMap, type ShvMap } from './rpcvalue';
-import { StringGetter } from './utils';
-type SubscriptionCallback = (path: string, method: string, param?: RpcValue) => void;
+import { RIGetter } from './utils';
+type SubscriptionCallback = (path: string, signal: string, param?: RpcValue) => void;
 type ResultOrError<T = RpcValue> = T | Error;
 type Login = {
     type: 'PLAIN';
@@ -209,6 +209,10 @@ export type CallRpcMethodOptions = {
     delayCallback?: (progress: number) => void;
     requestUserId?: boolean;
 };
+declare enum ShvApiVersion {
+    V2 = 0,
+    V3 = 1
+}
 declare class WsClient {
     private requestId;
     private pingTimerId;
@@ -219,6 +223,7 @@ declare class WsClient {
     private readonly websocket;
     private readonly options;
     private readonly timeout;
+    private shvApiVersion;
     constructor(options: WsClientOptions<MethodHandler>);
     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>>;
@@ -226,8 +231,9 @@ declare class WsClient {
     callRpcMethod(shvPath: string | undefined, method: 'ls', params?: RpcValue, options?: CallRpcMethodOptions): RpcRequestPromise<ResultOrError<LsResult>>;
     callRpcMethod(shvPath: string | undefined, method: string, params?: RpcValue, options?: CallRpcMethodOptions): RpcRequestPromise<ResultOrError>;
     sendRpcMessage(rpcMsg: RpcMessage): void;
-    subscribe(subscriber: string, pathGetter: StringGetter, method: string, callback: SubscriptionCallback): Promise<void>;
-    unsubscribe(subscriber: string, pathGetter: StringGetter, method: string): Promise<void>;
+    getShvApiVersion(): Promise<ShvApiVersion>;
+    subscribe(subscriber: string, riGetter: RIGetter, callback: SubscriptionCallback): Promise<void>;
+    unsubscribe(subscriber: string, riGetter: RIGetter): Promise<void>;
     sendPing(): void;
     accessGrantForMethodCall(path: string, method: string): RpcRequestPromise<ResultOrError<string>>;
     accessLevelForMethodCall(path: string, method: string): RpcRequestPromise<ResultOrError<number>>;

package/dist/ws-client.js

@@ -129,6 +129,11 @@ class RpcRequestPromise extends Promise {
         this.progressQuery = progressQuery;
     }
 }
+var ShvApiVersion;
+(function (ShvApiVersion) {
+    ShvApiVersion[ShvApiVersion["V2"] = 0] = "V2";
+    ShvApiVersion[ShvApiVersion["V3"] = 1] = "V3";
+})(ShvApiVersion || (ShvApiVersion = {}));
 class WsClient {
     requestId = 1;
     pingTimerId = undefined;
@@ -139,6 +144,7 @@ class WsClient {
     websocket;
     options;
     timeout;
+    shvApiVersion = undefined;
     constructor(options) {
         if (typeof options !== 'object') {
             throw new TypeError('No options object supplied');
@@ -150,9 +156,9 @@ class WsClient {
         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]);
+                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]);
                 }
             }
         };
@@ -420,44 +426,91 @@ class WsClient {
             this.websocket.send(dgram.buffer);
         }
     }
-    async subscribe(subscriber, pathGetter, method, callback) {
-        const path = await (0, utils_1.resolveString)(pathGetter);
-        if (this.subscriptions.some(val => val.subscriber === subscriber && val.path === path && val.method === method)) {
-            this.logDebug(`Already subscribed {$path}:${method} for subscriber ${subscriber}`);
+    async getShvApiVersion() {
+        if (this.shvApiVersion === undefined) {
+            const lsResult = await this.callRpcMethod('.broker', 'ls');
+            if (lsResult instanceof Error) {
+                console.warn('Cannot detect SHV API version. Using version 2 as a fallback.');
+                this.shvApiVersion = ShvApiVersion.V2;
+            }
+            else if (lsResult.includes('client')) {
+                this.shvApiVersion = ShvApiVersion.V3;
+            }
+            else {
+                this.shvApiVersion = ShvApiVersion.V2;
+            }
+        }
+        return this.shvApiVersion;
+    }
+    async subscribe(subscriber, riGetter, callback) {
+        const ri = await (0, utils_1.resolveRI)(riGetter);
+        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}`);
             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}`);
-            });
+        // 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)) {
+            switch (await this.getShvApiVersion()) {
+                case ShvApiVersion.V2: {
+                    const result = await this.callRpcMethod('.broker/app', 'subscribe', (0, rpcvalue_1.makeMap)({ signal, path }));
+                    if (result instanceof Error) {
+                        this.logDebug(`Couldn't subscribe to ${path}, ${signal}`);
+                    }
+                    if (result instanceof Error) {
+                        this.logDebug(`Couldn't subscribe to ${path}, ${signal}`);
+                        return;
+                    }
+                    break;
+                }
+                case ShvApiVersion.V3: {
+                    const result = await this.callRpcMethod('.broker/currentClient', 'subscribe', [ri.asString(), undefined]);
+                    if (result instanceof Error) {
+                        this.logDebug(`Couldn't subscribe to ${path}, ${signal}`);
+                        return;
+                    }
+                    break;
+                }
+            }
         }
         this.subscriptions.push({
             subscriber,
             path,
-            method,
+            signal,
             callback,
         });
     }
-    async unsubscribe(subscriber, pathGetter, method) {
-        const path = await (0, utils_1.resolveString)(pathGetter);
-        const idx = this.subscriptions.findIndex(val => val.subscriber === subscriber && val.path === path && val.method === method);
+    async unsubscribe(subscriber, riGetter) {
+        const ri = await (0, utils_1.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);
         if (idx === -1) {
-            this.logDebug(`No such subscription ${path}:${method} for subscriber ${subscriber}`);
+            this.logDebug(`No such subscription ${path}:${signal} 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)) {
+        // Unsubscribe on the broker only if there are no other subscriptions of this path:signal
+        if (this.subscriptions.some(val => val.path === path && val.signal === signal)) {
             return;
         }
-        this.callRpcMethod('.broker/app', 'unsubscribe', (0, rpcvalue_1.makeMap)({
-            method, path,
-        })).catch(() => {
-            this.logDebug(`Couldn't unsubscribe ${path}, ${method}`);
-        });
+        switch (await this.getShvApiVersion()) {
+            case ShvApiVersion.V2: {
+                const result = await this.callRpcMethod('.broker/app', 'unsubscribe', (0, rpcvalue_1.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 }));
+                if (result instanceof Error) {
+                    this.logDebug(`Couldn't unsubscribe ${path}, ${signal}`);
+                }
+                break;
+            }
+        }
     }
     sendPing() {
         this.callRpcMethod('.app', 'ping').catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libshv-js",
-  "version": "6.0.0",
+  "version": "7.0.1",
   "description": "Typescript implementation of libshv",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",