libshv-js 3.1.6 → 3.2.0

package/.github/workflows/publish.yml

@@ -0,0 +1,24 @@
+# vim: sw=2
+name: Publish
+
+on:
+  push:
+    branches: [ "main" ]
+
+jobs:
+  test:
+    name: Publish new version
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup node
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20.x'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Publish
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/package.json

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

package/src/chainpack.ts

@@ -1,5 +1,5 @@
 import {utf8ToString} from './cpon';
-import {type RpcValue, type RpcValueType, type DateTime, Decimal, Double, IMap, Int, MetaMap, RpcValueWithMetaData, ShvMap, UInt, withOffset} from './rpcvalue';
+import {type RpcValue, type RpcValueType, type DateTime, Decimal, Double, type IMap, Int, type MetaMap, RpcValueWithMetaData, type ShvMap, UInt, withOffset, shvMapType} from './rpcvalue';
 import {UnpackContext, PackContext} from './cpcontext';
 
 enum PackingSchema {
@@ -297,19 +297,24 @@ class ChainPackReader {
     }
 
     readMetaMap() {
-        return this.implReadMap(MetaMap);
+        return this.implReadMap('metamap');
     }
 
     readMap() {
-        return this.implReadMap(ShvMap);
+        return this.implReadMap('map');
     }
 
     readIMap() {
-        return this.implReadMap(IMap);
+        return this.implReadMap('imap');
     }
 
-    private implReadMap<MapType extends MetaMap | ShvMap | IMap>(MapTypeCtor: new () => MapType) {
-        const map = new MapTypeCtor();
+    private implReadMap(map_type: 'map'): ShvMap;
+    private implReadMap(map_type: 'imap'): IMap;
+    private implReadMap(map_type: 'metamap'): MetaMap;
+    private implReadMap(map_type: 'map' | 'imap' | 'metamap') {
+        const map: ShvMap | IMap | MetaMap = {
+            [shvMapType]: map_type,
+        };
         while (true) {
             const b = this.ctx.peekByte();
             if (b as PackingSchema === PackingSchema.Term) {
@@ -318,14 +323,14 @@ class ChainPackReader {
             }
             const key = this.read();
             const val = this.read();
-            if (map instanceof MetaMap && typeof key === 'string') {
-                map.value[key] = val;
-            } else if (map instanceof MetaMap && key instanceof Int) {
-                map.value[Number(key)] = val;
-            } else if (map instanceof ShvMap && typeof key === 'string') {
-                map.value[key] = val;
-            } else if (map instanceof IMap && key instanceof Int) {
-                map.value[Number(key)] = val;
+            if (map[shvMapType] === 'metamap' && typeof key === 'string') {
+                map[key] = val;
+            } else if (map[shvMapType] === 'metamap' && key instanceof Int) {
+                map[Number(key)] = val;
+            } else if (map[shvMapType] === 'map' && typeof key === 'string') {
+                map[key] = val;
+            } else if (map[shvMapType] === 'imap' && key instanceof Int) {
+                map[Number(key)] = val;
             } else {
                 throw new TypeError('Malformed map, invalid key');
             }
@@ -371,15 +376,21 @@ class ChainPackWriter {
             case Array.isArray(rpc_val):
                 this.writeList(rpc_val);
                 break;
-            case rpc_val instanceof IMap:
-                this.writeIMap(rpc_val);
-                break;
-            case rpc_val instanceof ShvMap:
-                this.writeMap(rpc_val);
-                break;
             case rpc_val instanceof Date:
                 this.writeDateTime(rpc_val);
                 break;
+            case rpc_val instanceof Double:
+                throw new Error('writing doubles not implemented');
+            case typeof rpc_val === 'object':
+                switch (rpc_val[shvMapType]) {
+                    case 'imap':
+                        this.writeIMap(rpc_val);
+                        break;
+                    case 'map':
+                        this.writeMap(rpc_val);
+                        break;
+                }
+                break;
             default:
                 console.log('Can\'t serialize', rpc_val);
                 throw new Error('Can\'t serialize');
@@ -545,19 +556,19 @@ class ChainPackWriter {
     }
 
     writeMapContent(map: MetaMap | ShvMap | IMap) {
-        for (const [key, value] of Object.entries(map.value)) {
+        for (const [key, value] of Object.entries(map)) {
             if (value === undefined) {
                 continue;
             }
 
-            if (map instanceof IMap) {
+            if (map[shvMapType] === 'imap') {
                 const int_key = Number(key);
                 if (Number.isNaN(int_key)) {
                     throw new TypeError('Invalid NaN IMap key');
                 }
 
                 this.writeInt(new Int(int_key));
-            } else if (map instanceof MetaMap) {
+            } else if (map[shvMapType] === 'metamap') {
                 const int_key = Number(key);
                 if (Number.isNaN(int_key)) {
                     this.writeJSString(key.toString());

package/src/cpon.ts

@@ -1,4 +1,4 @@
-import {type RpcValue, type RpcValueType, type DateTime, type List, Decimal, Double, IMap, Int, MetaMap, RpcValueWithMetaData, ShvMap, UInt, withOffset} from './rpcvalue';
+import {type RpcValue, type RpcValueType, type DateTime, type List, Decimal, Double, type IMap, Int, type MetaMap, RpcValueWithMetaData, type ShvMap, UInt, withOffset, shvMapType, isShvMap, isIMap} from './rpcvalue';
 import {PackContext, UnpackContext} from './cpcontext';
 
 const hexify = (byte: number) => {
@@ -412,15 +412,15 @@ class CponReader {
     }
 
     readMetaMap() {
-        return this.implReadMap(MetaMap, '>'.codePointAt(0)!);
+        return this.implReadMap('metamap', '>'.codePointAt(0)!);
     }
 
     readMap() {
-        return this.implReadMap(ShvMap, '}'.codePointAt(0)!);
+        return this.implReadMap('map', '}'.codePointAt(0)!);
     }
 
     readIMap() {
-        return this.implReadMap(IMap, '}'.codePointAt(0)!);
+        return this.implReadMap('imap', '}'.codePointAt(0)!);
     }
 
     readInt() {
@@ -550,8 +550,13 @@ class CponReader {
         return new Int(is_neg ? -mantisa : mantisa);
     }
 
-    private implReadMap<MapType extends MetaMap | ShvMap | IMap>(MapTypeCtor: new () => MapType, terminator: number) {
-        const map = new MapTypeCtor();
+    private implReadMap(map_type: 'map', terminator: number): ShvMap;
+    private implReadMap(map_type: 'imap', terminator: number): IMap;
+    private implReadMap(map_type: 'metamap', terminator: number): MetaMap;
+    private implReadMap(map_type: 'map' | 'imap' | 'metamap', terminator: number) {
+        const map: MetaMap | ShvMap | IMap = {
+            [shvMapType]: map_type,
+        };
         this.ctx.getByte(); // eat start
         while (true) {
             this.skipWhitespace();
@@ -568,14 +573,14 @@ class CponReader {
             this.skipWhitespace();
             const val = this.read();
 
-            if (map instanceof MetaMap && typeof key === 'string') {
-                map.value[key] = val;
-            } else if (map instanceof MetaMap && (key instanceof UInt || key instanceof Int)) {
-                map.value[Number(key)] = val;
-            } else if (map instanceof ShvMap && typeof key === 'string') {
-                map.value[key] = val;
-            } else if (map instanceof IMap && (key instanceof UInt || key instanceof Int)) {
-                map.value[Number(key)] = val;
+            if (map[shvMapType] === 'metamap' && typeof key === 'string') {
+                map[key] = val;
+            } else if (map[shvMapType] === 'metamap' && (key instanceof UInt || key instanceof Int)) {
+                map[Number(key)] = val;
+            } else if (map[shvMapType] === 'map' && typeof key === 'string') {
+                map[key] = val;
+            } else if (map[shvMapType] === 'imap' && (key instanceof UInt || key instanceof Int)) {
+                map[Number(key)] = val;
             } else {
                 throw new TypeError('Malformed map, invalid key');
             }
@@ -625,15 +630,19 @@ class CponWriter {
             case Array.isArray(rpc_val):
                 this.writeList(rpc_val);
                 break;
-            case rpc_val instanceof IMap:
-                this.writeIMap(rpc_val);
-                break;
-            case rpc_val instanceof ShvMap:
-                this.writeMap(rpc_val);
-                break;
             case rpc_val instanceof Date:
                 this.writeDateTime(rpc_val);
                 break;
+            case typeof rpc_val === 'object':
+                switch (rpc_val[shvMapType]) {
+                    case 'imap':
+                        this.writeIMap(rpc_val);
+                        break;
+                    case 'map':
+                        this.writeMap(rpc_val);
+                        break;
+                }
+                break;
             default:
                 console.log('Can\'t serialize rpc value', rpc_val);
                 throw new Error('Can\'t serialize rpc value');
@@ -761,7 +770,7 @@ class CponWriter {
         this.increaseIndentIfNotOneLiner(map);
         this.doIndentIfNotOneliner(map);
         let first = true;
-        for (const [key, value] of Object.entries(map.value)) {
+        for (const [key, value] of Object.entries(map)) {
             if (value === undefined) {
                 continue;
             }
@@ -771,14 +780,14 @@ class CponWriter {
             }
             first = false;
 
-            if (map instanceof IMap) {
+            if (map[shvMapType] === 'imap') {
                 const int_key = Number(key);
                 if (Number.isNaN(int_key)) {
                     throw new TypeError('Invalid NaN IMap key');
                 }
 
                 this.writeInt(new Int(int_key));
-            } else if (map instanceof MetaMap) {
+            } else if (map[shvMapType] === 'metamap') {
                 const int_key = Number(key);
                 if (Number.isNaN(int_key)) {
                     this.ctx.putByte('"'.codePointAt(0)!);
@@ -881,10 +890,10 @@ class CponWriter {
         const keyThreshold = Array.isArray(value) ? 10 : 5;
 
         if (Array.isArray(value)) {
-            return value.length <= keyThreshold && !(value.some(x => Array.isArray(x) || x instanceof ShvMap || x instanceof IMap));
+            return value.length <= keyThreshold && !(value.some(x => Array.isArray(x) || isShvMap(x) || isIMap(x)));
         }
 
-        return Object.keys(value.value).length <= keyThreshold && !(Object.values(value.value).some(x => Array.isArray(x) || x instanceof ShvMap || x instanceof IMap));
+        return Object.keys(value).length <= keyThreshold && !(Object.values(value).some(x => Array.isArray(x) || isShvMap(x) || isIMap(x)));
     }
 
     private increaseIndentIfNotOneLiner(value: MetaMap | ShvMap | IMap | List) {

package/src/rpcmessage.ts

@@ -1,4 +1,4 @@
-import {IMap, Int, MetaMap, type RpcValue, RpcValueWithMetaData} from './rpcvalue';
+import {type IMap, Int, isIMap, makeIMap, makeMetaMap, type MetaMap, type RpcValue, RpcValueWithMetaData} from './rpcvalue';
 import {toCpon} from './cpon';
 import {toChainPack} from './chainpack';
 
@@ -30,19 +30,19 @@ enum ErrorCode {
     NotImplemented = 12,
 }
 
-type ErrorMap = IMap<{
+export type ErrorMap = {
     [ERROR_CODE]: Int<ErrorCode>;
     [ERROR_MESSAGE]?: string;
     [ERROR_DATA]?: RpcValue;
-}>;
+};
 
 class RpcError extends Error {
     constructor(private readonly err_info: ErrorMap) {
-        super(err_info.value[ERROR_MESSAGE]);
+        super(err_info[ERROR_MESSAGE] ?? 'Unknown RpcError');
     }
 
     data() {
-        return this.err_info.value[ERROR_DATA];
+        return this.err_info[ERROR_DATA];
     }
 }
 
@@ -66,12 +66,12 @@ class RpcMessage {
     meta: MetaMap;
     constructor(rpc_val?: RpcValue) {
         if (rpc_val === undefined) {
-            this.value = new IMap();
-            this.meta = new MetaMap();
+            this.value = makeIMap({});
+            this.meta = makeMetaMap({});
             return;
         }
 
-        if (!(rpc_val instanceof RpcValueWithMetaData && rpc_val.value instanceof IMap)) {
+        if (!(rpc_val instanceof RpcValueWithMetaData && isIMap(rpc_val.value))) {
             throw new TypeError(`RpcMessage initialized with a non-IMap: ${toCpon(rpc_val)}`);
         }
 
@@ -96,58 +96,60 @@ class RpcMessage {
     }
 
     requestId(): Int | undefined {
-        return (this.meta.value[TagRequestId] as Int);
+        return (this.meta[TagRequestId] as Int);
     }
 
     setRequestId(id: number | Int) {
-        this.meta.value[TagRequestId] = new Int(id);
+        this.meta[TagRequestId] = new Int(id);
     }
 
     callerIds(): RpcValue[] | undefined {
-        return this.meta.value[TagCallerIds] as RpcValue[];
+        return this.meta[TagCallerIds] as RpcValue[];
     }
 
     setCallerIds(ids: RpcValue[]) {
-        this.meta.value[TagCallerIds] = ids;
+        this.meta[TagCallerIds] = ids;
     }
 
     shvPath(): string | undefined {
-        return (this.meta.value[TagShvPath] as string);
+        return (this.meta[TagShvPath] as string);
     }
 
     setShvPath(val: string) {
-        this.meta.value[TagShvPath] = val;
+        this.meta[TagShvPath] = val;
     }
 
     method(): string | undefined {
-        return (this.meta.value[TagMethod] as string);
+        return (this.meta[TagMethod] as string);
     }
 
     setMethod(val: string) {
-        this.meta.value[TagMethod] = val;
+        this.meta[TagMethod] = val;
     }
 
     params() {
-        return this.value.value[KeyParams];
+        return this.value[KeyParams];
     }
 
     setParams(params: RpcValue) {
-        this.value.value[KeyParams] = params;
+        this.value[KeyParams] = params;
     }
 
     resultOrError() {
-        if (this.value.value[KeyError] !== undefined) {
-            if (!(this.value.value[KeyError] instanceof IMap)) {
+        if (Object.hasOwn(this.value, KeyError)) {
+            if (!isIMap(this.value[KeyError])) {
                 return new ProtocolError('Response had an error, but this error was not a map');
             }
 
-            const error_map = this.value.value[KeyError];
-            if (error_map.value[ERROR_CODE] === undefined) {
+            const error_map = this.value[KeyError];
+            if (!(error_map[ERROR_CODE] instanceof Int)) {
                 return new ProtocolError('Response had an error, but this error did not contain at least an error code');
             }
 
+            const code = error_map[ERROR_CODE];
+
             const ErrorType = (() => {
-                switch ((this.value.value[KeyError] as ErrorMap).value[ERROR_CODE].value) {
+                switch (code.value) {
                     case ErrorCode.InvalidRequest: return InvalidRequest;
                     case ErrorCode.MethodNotFound: return MethodNotFound;
                     case ErrorCode.InvalidParams: return InvalidParams;
@@ -160,25 +162,26 @@ class RpcMessage {
                     case ErrorCode.LoginRequired: return LoginRequired;
                     case ErrorCode.UserIDRequired: return UserIDRequired;
                     case ErrorCode.NotImplemented: return NotImplemented;
+                    default: return Unknown;
                 }
             })();
 
-            return new ErrorType(this.value.value[KeyError] as ErrorMap);
+            return new ErrorType(this.value[KeyError] as unknown as ErrorMap);
         }
 
-        if (Object.hasOwn(this.value.value, KeyResult)) {
-            return this.value.value[KeyResult];
+        if (Object.hasOwn(this.value, KeyResult)) {
+            return this.value[KeyResult];
         }
 
         return new ProtocolError('Response included neither result nor error');
     }
 
     setResult(result: RpcValue) {
-        this.value.value[KeyResult] = result;
+        this.value[KeyResult] = result;
     }
 
     setError(error: string) {
-        this.value.value[KeyError] = error;
+        this.value[KeyError] = error;
     }
 
     toCpon() {

package/src/rpcvalue.ts

@@ -71,15 +71,19 @@ const withOffset = (date: Date, utc_offset?: number) => {
 };
 export type List = RpcValue[];
 
-type ShvMapDefaultType = Record<string, RpcValue | undefined>;
-class ShvMap<T extends ShvMapDefaultType = ShvMapDefaultType> {
-    constructor(public value: T = {} as T) {}
-}
+const shvMapType = Symbol('shvMapType');
 
-type IMapDefaultType = Record<number, RpcValue | undefined>;
-class IMap<T extends IMapDefaultType = IMapDefaultType> {
-    constructor(public value: T = {} as T) {}
-}
+type IMap<T extends Record<number, RpcValue> = Record<number, any>> = {
+    [Key in keyof T]: T[Key];
+} & {
+    [shvMapType]: 'imap';
+};
+
+type ShvMap<T extends Record<string, RpcValue> = Record<string, any>> = {
+    [Key in keyof T]: T[Key];
+} & {
+    [shvMapType]: 'map';
+};
 
 export type RpcValueType =
     Null |
@@ -95,12 +99,30 @@ export type RpcValueType =
     ShvMap |
     IMap;
 
-class MetaMap {
-    value: Record<number | string, RpcValue | undefined>;
-    constructor(obj?: Record<number | string, RpcValue | undefined>) {
-        this.value = obj ?? {};
-    }
-}
+type MetaMap<T extends Record<string | number, RpcValue> = Record<string | number, RpcValue>> = {
+    [Key in keyof T]: T[Key];
+} & {
+    [shvMapType]: 'metamap';
+};
+
+const isShvMap = (x: RpcValue): x is ShvMap => typeof x === 'object' && (x as ShvMap)[shvMapType] === 'map';
+
+const isIMap = (x: RpcValue): x is IMap => typeof x === 'object' && (x as IMap)[shvMapType] === 'imap';
+
+const makeMetaMap = <T extends Record<string | number, RpcValue> = Record<string | number, RpcValue>>(x: T = {} as T): MetaMap<T> => ({
+    ...x,
+    [shvMapType]: 'metamap',
+});
+
+const makeIMap = <T extends Record<number, RpcValue> = Record<number, RpcValue>>(x: T = {} as T): IMap<T> => ({
+    ...x,
+    [shvMapType]: 'imap',
+});
+
+const makeMap = <T extends Record<string, RpcValue> = Record<string, RpcValue>>(x: T = {} as T): ShvMap<T> => ({
+    ...x,
+    [shvMapType]: 'map',
+});
 
 class RpcValueWithMetaData {
     constructor(public value: RpcValueType, public meta: MetaMap) {}
@@ -108,4 +130,4 @@ class RpcValueWithMetaData {
 
 export type RpcValue = RpcValueType | RpcValueWithMetaData;
 
-export {Decimal, Double, Int, IMap, MetaMap, RpcValueWithMetaData, ShvMap, UInt, withOffset};
+export {shvMapType, Decimal, Double, type IMap, Int, type MetaMap, RpcValueWithMetaData, type ShvMap, UInt, withOffset, makeMap, makeIMap, makeMetaMap, isIMap, isShvMap};

package/src/ws-client.ts

@@ -1,7 +1,7 @@
 import {ChainPackReader, ChainpackProtocolType, ChainPackWriter} from './chainpack';
 import {type CponReader, CponProtocolType} from './cpon';
 import {ERROR_MESSAGE, ErrorCode, ERROR_CODE, RpcMessage, type RpcResponse, MethodCallTimeout} from './rpcmessage';
-import {type RpcValue, type Null, Int, IMap, ShvMap} from './rpcvalue';
+import {type RpcValue, type Null, Int, type IMap, type ShvMap, makeMap, makeIMap} from './rpcvalue';
 
 const DEFAULT_TIMEOUT = 5000;
 
@@ -115,14 +115,14 @@ class WsClient {
         this.websocket.addEventListener('open', () => {
             this.logDebug('CONNECTED');
             this.callRpcMethod(undefined, 'hello').then(() => {
-                const params = new ShvMap({
-                    login: new ShvMap({
+                const params = makeMap({
+                    login: makeMap({
                         password: this.password,
                         type: this.loginType,
                         user: this.user,
                     }),
-                    options: new ShvMap({
-                        device: this.mountPoint === 'string' ? new ShvMap({mountPoint: this.mountPoint}) : undefined,
+                    options: makeMap({
+                        device: this.mountPoint === 'string' ? makeMap({mountPoint: this.mountPoint}) : undefined,
                     }),
                 });
                 return this.callRpcMethod(undefined, 'login', params);
@@ -196,7 +196,7 @@ class WsClient {
 
         const promise = new Promise<RpcResponse>(resolve => {
             this.rpcHandlers[rq_id] = {resolve, timeout_handle: self.setTimeout(() => {
-                resolve(new MethodCallTimeout(new IMap({
+                resolve(new MethodCallTimeout(makeIMap({
                     [ERROR_CODE]: new Int(ErrorCode.MethodCallTimeout),
                     [ERROR_MESSAGE]: `Shv call timeout after: ${this.timeout} msec.`,
                 })));
@@ -236,7 +236,7 @@ class WsClient {
         }
         // 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', new ShvMap({
+            this.callRpcMethod('.broker/app', 'subscribe', makeMap({
                 method, path,
             })).catch(() => {
                 this.logDebug(`Couldn't subscribe to ${path}, ${method}`);
@@ -261,7 +261,7 @@ class WsClient {
         if (this.subscriptions.some(val => val.path === path && val.method === method)) {
             return;
         }
-        this.callRpcMethod('.broker/app', 'unsubscribe', new ShvMap({
+        this.callRpcMethod('.broker/app', 'unsubscribe', makeMap({
             method, path,
         })).catch(() => {
             this.logDebug(`Couldn't unsubscribe ${path}, ${method}`);

package/src/zod.ts

@@ -1,9 +1,9 @@
 import {z, type ZodType} from 'zod';
-import {IMap, Int, type RpcValue, ShvMap} from './rpcvalue';
+import {type IMap, Int, isIMap, isShvMap, type RpcValue, type ShvMap} from './rpcvalue';
 
-export const map = <T extends Record<string, ZodType<any, any, any>>>(schema: T) => z.custom<ShvMap<{[K in keyof T]: z.infer<T[K]>}>>((data: RpcValue) => data instanceof ShvMap && z.object(schema).safeParse(data.value).success);
-export const recmap = <T extends ZodType<any, any, any>>(schema: T) => z.custom<ShvMap<Record<string, z.infer<T>>>>((data: RpcValue) => data instanceof ShvMap && z.record(z.string(), schema).safeParse(data.value).success);
-export const imap = <T extends Record<string, ZodType<any, any, any>>>(schema: T) => z.custom<IMap<{[K in keyof T]: z.infer<T[K]>}>>((data: RpcValue) => data instanceof IMap && z.object(schema).safeParse(data.value).success);
+export const map = <T extends Record<string, ZodType<any, any, any>>>(schema: T) => z.custom<ShvMap<{[K in keyof T]: z.infer<T[K]>}>>((data: RpcValue) => isShvMap(data) && z.object(schema).safeParse(data).success);
+export const recmap = <T extends ZodType<any, any, any>>(schema: T) => z.custom<ShvMap<Record<string, z.infer<T>>>>((data: RpcValue) => isShvMap(data) && z.record(z.string(), schema).safeParse(data).success);
+export const imap = <T extends Record<string, ZodType<any, any, any>>>(schema: T) => z.custom<IMap<{[K in keyof T]: z.infer<T[K]>}>>((data: RpcValue) => isIMap(data) && z.object(schema).safeParse(data).success);
 export const int = () => z.custom<Int>((data: RpcValue) => data instanceof Int);
 
 export * from 'zod';

package/deno.json

@@ -1,8 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": ["dom", "dom.iterable", "deno.window"]
-  },
-  "tasks": {
-    "lint": "deno run --allow-read --allow-write --allow-net --allow-sys --allow-env npm:xo --reporter unix src/*"
-  }
-}