libshv-js 3.14.0 → 3.15.1

package/package.json

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

package/src/ws-client.ts

@@ -64,11 +64,10 @@ export class RequestHandler {
 
 export const LsParamZod = z.undefined().or(z.string());
 export const DirParamZod = z.undefined().or(z.boolean()).or(z.string());
-type DirParam = z.infer<typeof DirParamZod>;
 
 export type DirEntry = IMap<{
     [DIR_NAME]: string;
-    [DIR_FLAGS]: DirFlags;
+    [DIR_FLAGS]: number;
     [DIR_PARAM]: string | Null;
     [DIR_RESULT]: string | Null;
     [DIR_ACCESS]: Int;
@@ -79,10 +78,8 @@ export type DirEntry = IMap<{
 export type DirResult = DirEntry[];
 
 export type MethodHandler = {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    paramParser: z.ZodType<any>,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    handler: (shvPath: string, method: string, params: any, delay: (progress: number) => void) => Promise<RpcValue> | RpcValue | RequestHandler,
+    paramParser: z.ZodType<RpcValue>,
+    handler: (shvPath: string, method: string, params: RpcValue, delay: (progress: number) => void) => Promise<RpcValue> | RpcValue | RequestHandler,
 };
 
 type WsClientOptionsLogin = WsClientOptionsCommon & {
@@ -93,7 +90,10 @@ type WsClientOptionsLogin = WsClientOptionsCommon & {
     onConnected: () => void;
     onConnectionFailure: (error: Error) => void;
     onDisconnected: () => void;
-    onRequest: (shvPath: string) => Array<{entry: DirEntry} & MethodHandler> | undefined;
+    onRequest: (shvPath: string) => {
+        ls: (shvPath: string) => string[] | Promise<string[]>;
+        dirEntries: Array<{entry: DirEntry} & MethodHandler>;
+    } | undefined;
 };
 
 type WsClientOptionsWorkflows = WsClientOptionsCommon & {
@@ -255,9 +255,12 @@ class WsClient {
                 if (RPC_MESSAGE_ABORT in request.value) {
                     const requestHandler = this.requestHandlers.get(requestId);
 
-                    if (request.value[RPC_MESSAGE_ABORT] === true && requestHandler?.options.onAbort !== undefined) {
+                    if (request.value[RPC_MESSAGE_ABORT] === true) {
                         this.abortedRequests.add(requestId);
-                        requestHandler.options.onAbort();
+
+                        if (requestHandler?.options.onAbort !== undefined) {
+                            requestHandler.options.onAbort();
+                        }
                     }
 
                     if (request.value[RPC_MESSAGE_ABORT] === false && requestHandler?.options.onProgressQuery !== undefined) {
@@ -291,9 +294,18 @@ class WsClient {
                         const dirEntry = makeIMap({
                             [DIR_NAME]: 'dir',
                             [DIR_FLAGS]: 0,
-                            [DIR_PARAM]: '',
-                            [DIR_RESULT]: '',
-                            [DIR_ACCESS]: accessLevelFromAccessString('rd'),
+                            [DIR_PARAM]: 'DirParam',
+                            [DIR_RESULT]: 'DirResult',
+                            [DIR_ACCESS]: accessLevelFromAccessString('bws'),
+                            [DIR_SIGNALS]: makeMap({}),
+                            [DIR_EXTRA]: 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({}),
                         });
@@ -302,8 +314,8 @@ class WsClient {
                                 return {
                                     entry: dirEntry,
                                     paramParser: DirParamZod,
-                                    handler(_shvPath, _method, param: DirParam) {
-                                        const methodsResult = [dirEntry, ...methods.map(method => method.entry)];
+                                    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[DIR_NAME] === param) ?? false;
@@ -314,8 +326,16 @@ class WsClient {
                                         }
                                     },
                                 };
+                            case 'ls':
+                                return {
+                                    entry: lsEntry,
+                                    paramParser: LsParamZod,
+                                    handler(shvPath) {
+                                        return methods.ls(shvPath);
+                                    },
+                                };
                             default:
-                                return methods.find(method => method.entry[DIR_NAME] === methodName);
+                                return methods.dirEntries.find(method => method.entry[DIR_NAME] === methodName);
                         }
                     })();
 
@@ -332,7 +352,7 @@ class WsClient {
                     const requestParam = request.value[RPC_MESSAGE_PARAMS];
                     const parsedParam = methodDefinition.paramParser.safeParse(requestParam);
                     if (!parsedParam.success) {
-                        throw new InvalidParams(`Unexpected param for method ${methodName} on path ${shvPath}: ${toCpon(requestParam)}`);
+                        throw new InvalidParams(`Unexpected param for method ${methodName} on path '${shvPath}': ${toCpon(requestParam)}`);
                     }
 
                     let result = methodDefinition.handler(