libshv-js 3.2.2 → 3.2.4

package/package.json

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

package/src/rpcvalue.ts

@@ -6,6 +6,7 @@ class Int<T = number> {
             this.value = u.value;
             return;
         }
+
         if (!Number.isInteger(u)) {
             throw new TypeError('Value for Int must a positive integral number');
         }
@@ -18,10 +19,15 @@ class Int<T = number> {
     }
 }
 
-class UInt {
-    readonly value: number;
+class UInt<T extends number = number> {
+    readonly value: T;
+
+    constructor(u: T | UInt<T>) {
+        if (u instanceof UInt) {
+            this.value = u.value;
+            return;
+        }
 
-    constructor(u: number) {
         if (u < 0 || !Number.isInteger(u)) {
             throw new Error(`Invalid value '${u}' for UInt must a positive integral number`);
         }

package/src/zod.ts

@@ -1,10 +1,12 @@
 import {z, type ZodType} from 'zod';
-import {type IMap, Int, isIMap, isShvMap, type RpcValue, type ShvMap, UInt} from './rpcvalue';
+import {Int, shvMapType, UInt} 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) => 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 const uint = () => z.custom<UInt>((data: RpcValue) => data instanceof UInt);
+export const map = <T extends Record<string, ZodType<any, any, any>>>(schema: T) => z.object(schema).and(z.object({[shvMapType]: z.literal('map')}));
+export const recmap = <T extends ZodType<any, any, any>>(schema: T) => z.record(z.string(), schema).and(z.object({[shvMapType]: z.literal('map')}));
+export const imap = <T extends Record<string, ZodType<any, any, any>>>(schema: T) => z.object(schema).and(z.object({[shvMapType]: z.literal('imap')}));
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-arguments -- Zod needs the default argument, otherwise it'll infer as Int<unknown>
+export const int = () => z.instanceof(Int<number>);
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-arguments -- Zod needs the default argument, otherwise it'll infer as UInt<unknown>
+export const uint = () => z.instanceof(UInt<number>);
 
 export * from 'zod';