@akala/pm 15.2.9 → 15.3.0

package/package.json

@@ -4,11 +4,11 @@
     "pm": "dist/esm/cli.js",
     "pm-fork": "dist/esm/fork.js"
   },
-  "version": "15.2.9",
+  "version": "15.3.0",
   "scripts": {
     "test": "echo 1",
-    "generate": "ac generate dist/esm/commands commands.json --name pm && ac generate dist/esm/cli-commands cli-commands.json --name pm",
-    "generate-metadata": "ac generate-metadata commands.json src/container.ts && ac generate-metadata cli-commands.json src/cli-container.ts",
+    "generate": "akala sdk generate dist/esm/commands commands.json --name pm && akala sdk generate dist/esm/cli-commands cli-commands.json --name pm",
+    "generate-metadata": "akala sdk generate-metadata commands.json src/container.ts && akala sdk generate-metadata cli-commands.json src/cli-container.ts",
     "prepack": "../../makeCjs.sh",
     "akala-install": "akala plugins add dist/esm/akala.mjs"
   },
@@ -29,11 +29,11 @@
     "src/fork.ts"
   ],
   "dependencies": {
-    "@akala/cli": "^5.9.3",
-    "@akala/commands": "^16.0.0",
-    "@akala/config": "^6.0.74",
-    "@akala/core": "^39.4.0",
-    "@akala/json-rpc-ws": "^11.0.82",
+    "@akala/cli": "^5.10.0",
+    "@akala/commands": "^16.1.0",
+    "@akala/config": "^6.0.75",
+    "@akala/core": "^39.5.0",
+    "@akala/json-rpc-ws": "^12.0.0",
     "reflect-metadata": "^0.2.2",
     "source-map-support": "^0.5.21"
   },

package/src/ipc-adapter.ts

@@ -1,13 +1,13 @@
 import { ChildProcess } from "child_process";
 import * as jsonrpc from '@akala/json-rpc-ws';
-import { SocketAdapterEventMap } from "@akala/json-rpc-ws";
+import { AllEventKeys, AllEvents, EventArgs, EventKeys, EventListener, EventOptions, EventReturnType, StatefulSubscription, Subscription, TeardownManager } from "@akala/core";
 
-export class IpcAdapter implements jsonrpc.SocketAdapter
+export class IpcAdapter extends TeardownManager implements jsonrpc.SocketAdapter
 {
     get open(): boolean { return !!this.cp.pid; }
 
 
-    pipe(socket: jsonrpc.SocketAdapter<unknown>)
+    pipe(socket: jsonrpc.SocketAdapter)
     {
         this.on('message', (message) => socket.send(message));
         this.on('close', () => socket.close());
@@ -25,7 +25,11 @@ export class IpcAdapter implements jsonrpc.SocketAdapter
         else
             console.warn(`process ${this.cp.pid} does not support send over IPC`);
     }
-    off<K extends keyof SocketAdapterEventMap>(event: K, handler: (ev: SocketAdapterEventMap[K]) => void): void
+
+    public off<const TEvent extends AllEventKeys<jsonrpc.SocketAdapterAkalaEventMap>>(
+        event: TEvent,
+        handler: EventListener<AllEvents<jsonrpc.SocketAdapterAkalaEventMap>[TEvent]>
+    ): boolean
     {
         switch (event)
         {
@@ -39,41 +43,59 @@ export class IpcAdapter implements jsonrpc.SocketAdapter
                 this.cp.off('disconnect', handler);
                 break;
         }
+        return true;
     }
-    on<K extends keyof SocketAdapterEventMap>(event: K, handler: (ev: SocketAdapterEventMap[K]) => void): void
+
+    public on<const TEvent extends AllEventKeys<jsonrpc.SocketAdapterAkalaEventMap>>(
+        event: TEvent,
+        handler: EventListener<AllEvents<jsonrpc.SocketAdapterAkalaEventMap>[TEvent]>,
+        options?: EventOptions<AllEvents<jsonrpc.SocketAdapterAkalaEventMap>[TEvent]>
+    ): Subscription
     {
         switch (event)
         {
             case 'message':
-                this.cp.on('message', handler);
-                break;
+                if (options?.once)
+                    this.cp.on('message', handler);
+                else
+                    this.cp.on('message', handler);
+                return new StatefulSubscription(() => this.cp.off('message', handler)).unsubscribe;
             case 'open':
                 handler(null);
                 break;
             case 'close':
-                this.cp.on('disconnect', handler);
-                break;
+                if (options?.once)
+                    this.cp.once('disconnect', handler);
+                else
+                    this.cp.on('disconnect', handler);
+                return new StatefulSubscription(() => this.cp.off('disconnect', handler)).unsubscribe;
         }
     }
 
-    once<K extends keyof SocketAdapterEventMap>(event: K, handler: (ev: SocketAdapterEventMap[K]) => void): void
+    public once<const TEvent extends AllEventKeys<jsonrpc.SocketAdapterAkalaEventMap>>(
+        event: TEvent,
+        handler: EventListener<AllEvents<jsonrpc.SocketAdapterAkalaEventMap>[TEvent]>,
+    ): Subscription
     {
-        switch (event)
-        {
-            case 'message':
-                this.cp.once('message', handler);
-                break;
-            case 'open':
-                handler(null);
-                break;
-            case 'close':
-                this.cp.once('disconnect', () => handler(null));
-                break;
-        }
+        return this.on(event, handler, { once: true } as EventOptions<AllEvents<jsonrpc.SocketAdapterAkalaEventMap>[TEvent]>)
     }
 
     constructor(private cp: ChildProcess | typeof process)
     {
+        super();
+    }
+    hasListener<const TKey extends AllEventKeys<jsonrpc.SocketAdapterAkalaEventMap>>(name: TKey)
+    {
+        if (name === 'open')
+            return false;
+        return !!this.cp.listenerCount(name);
+    }
+    get definedEvents(): AllEventKeys<jsonrpc.SocketAdapterAkalaEventMap>[]
+    {
+        return (['close', 'error', 'message'] as const).filter(ev => this.hasListener(ev));
+    }
+    emit<const TEvent extends EventKeys<jsonrpc.SocketAdapterAkalaEventMap>>(event: TEvent, ...args: EventArgs<jsonrpc.SocketAdapterAkalaEventMap[TEvent]>): false | EventReturnType<jsonrpc.SocketAdapterAkalaEventMap[TEvent]>
+    {
+        throw new Error("Method not implemented.");
     }
-
 }

package/src/messageport-adapter.ts

@@ -1,7 +1,8 @@
-import { SocketAdapter, SocketAdapterEventMap } from "@akala/json-rpc-ws";
+import { AllEventKeys, AllEvents, EventArgs, EventKeys, EventListener, EventOptions, EventReturnType, StatefulSubscription, Subscription, TeardownManager } from "@akala/core";
+import { SocketAdapter, SocketAdapterAkalaEventMap } from "@akala/json-rpc-ws";
 import { MessagePort, Worker } from "worker_threads";
 
-export class MessagePortAdapter implements SocketAdapter
+export class MessagePortAdapter extends TeardownManager implements SocketAdapter
 {
     private isOpen: boolean = true;
 
@@ -17,48 +18,70 @@ export class MessagePortAdapter implements SocketAdapter
     {
         this.cp.postMessage(data);
     }
-    on<K extends keyof SocketAdapterEventMap>(event: K, handler: (ev: SocketAdapterEventMap[K]) => void): void
+
+    public on<const TEvent extends AllEventKeys<SocketAdapterAkalaEventMap>>(
+        event: TEvent,
+        handler: EventListener<AllEvents<SocketAdapterAkalaEventMap>[TEvent]>,
+        options?: EventOptions<AllEvents<SocketAdapterAkalaEventMap>[TEvent]>
+    ): Subscription
     {
         switch (event)
         {
             case 'message':
-                this.cp.on('message', handler);
-                break;
+                if (options?.once)
+                    this.cp.on('message', handler);
+                else
+                    this.cp.on('message', handler);
+                return new StatefulSubscription(() => this.cp.off('message', handler)).unsubscribe;
             case 'open':
                 handler(null);
                 break;
             case 'close':
-                this.cp.on('disconnect', handler);
-                break;
+                if (options?.once)
+                    this.cp.once('disconnect', handler);
+                else
+                    this.cp.on('disconnect', handler);
+                return new StatefulSubscription(() => this.cp.off('disconnect', handler)).unsubscribe;
         }
     }
 
-    once<K extends keyof SocketAdapterEventMap>(event: K, handler: (ev: SocketAdapterEventMap[K]) => void): void
+    public once<const TEvent extends AllEventKeys<SocketAdapterAkalaEventMap>>(
+        event: TEvent,
+        handler: EventListener<AllEvents<SocketAdapterAkalaEventMap>[TEvent]>,
+    ): Subscription
+    {
+        return this.on(event, handler, { once: true } as EventOptions<AllEvents<SocketAdapterAkalaEventMap>[TEvent]>)
+    }
+
+
+    constructor(private cp: MessagePort | Worker)
+    {
+        super();
+        cp.on('close', () => this.isOpen = false);
+    }
+
+    public off<const TEvent extends AllEventKeys<SocketAdapterAkalaEventMap>>(
+        event: TEvent,
+        handler: EventListener<AllEvents<SocketAdapterAkalaEventMap>[TEvent]>
+    ): boolean
     {
         switch (event)
         {
             case 'message':
-                this.cp.once('message', handler);
+                this.cp.off('message', handler);
                 break;
             case 'open':
                 handler(null);
                 break;
             case 'close':
-                this.cp.once('close', () => handler(null));
+                this.cp.off('disconnect', handler);
                 break;
         }
+        return true;
     }
 
-    constructor(private cp: MessagePort | Worker)
-    {
-        cp.on('close', () => this.isOpen = false);
-    }
-    off<K extends keyof SocketAdapterEventMap>(event: K, handler?: (this: unknown, ev: SocketAdapterEventMap[K]) => void): void
-    {
-        this.cp.off(event, handler);
-    }
 
-    pipe(socket: SocketAdapter<unknown>)
+    pipe(socket: SocketAdapter)
     {
         this.on('message', (message) => socket.send(message));
         this.on('close', () => socket.close());
@@ -78,4 +101,21 @@ export class MessagePortAdapter implements SocketAdapter
     // _read()
     // {
     // }
+
+
+    hasListener<const TKey extends AllEventKeys<SocketAdapterAkalaEventMap>>(name: TKey)
+    {
+        if (name === 'open')
+            return false;
+        return !!this.cp.listenerCount(name);
+    }
+    get definedEvents(): AllEventKeys<SocketAdapterAkalaEventMap>[]
+    {
+        return (['close', 'error', 'message'] as const).filter(ev => this.hasListener(ev));
+    }
+
+    emit<const TEvent extends EventKeys<SocketAdapterAkalaEventMap>>(event: TEvent, ...args: EventArgs<SocketAdapterAkalaEventMap[TEvent]>): false | EventReturnType<SocketAdapterAkalaEventMap[TEvent]>
+    {
+        throw new Error("Method not implemented.");
+    }
 }

package/src/virtual-scroll-prefixer.ts

@@ -0,0 +1,67 @@
+import { Transform } from 'stream';
+import { NewLinePrefixer } from './new-line-prefixer.js';
+
+export class VirtualScrollPrefixer extends Transform
+{
+    private buffer: string[] = [];
+    private readonly maxLines: number;
+    private readonly prefixer: NewLinePrefixer;
+
+    constructor(prefix: string, options: { maxLines?: number, useColors?: boolean } = {})
+    {
+        super();
+        this.maxLines = options.maxLines || 5;
+        this.prefixer = new NewLinePrefixer(prefix, { useColors: options.useColors });
+    }
+
+    _transform(chunk: Buffer | string, encoding: string, callback: () => void)
+    {
+        // Convert chunk to string if it's a buffer
+        const str = Buffer.isBuffer(chunk) ? chunk.toString() : chunk;
+
+        // Split the input into lines
+        const lines = str.split('\n');
+
+        // Process each line
+        lines.forEach((line, i) =>
+        {
+            if (line || i < lines.length - 1)
+            { // Skip empty lines at the end
+                // Add the new line to the buffer
+                this.buffer.push(line);
+
+                // If buffer exceeds max lines, remove the oldest line
+                if (this.buffer.length > this.maxLines)
+                {
+                    this.buffer.shift();
+                }
+
+                // Clear the terminal and rewrite all lines
+                this.push('\x1b[' + this.maxLines + 'A\x1b[0G\x1b[0J'); // Move cursor up and clear screen below
+
+                // Write each line in the buffer
+                this.buffer.forEach(bufferedLine =>
+                {
+                    const prefixed = new Promise<string>((resolve) =>
+                    {
+                        this.prefixer._transform(bufferedLine, 'utf8', () =>
+                        {
+                            this.prefixer.once('data', (data) =>
+                            {
+                                resolve(data);
+                            });
+                        });
+                    });
+                    prefixed.then(data => this.push(data + '\n'));
+                });
+            }
+        });
+
+        callback();
+    }
+
+    _flush(callback: () => void)
+    {
+        callback();
+    }
+}