@nsshunt/stsappframework 3.1.131 → 3.1.133

package/src/redisMessageHandler.ts

@@ -2,12 +2,14 @@
 import { TinyEmitter } from "tiny-emitter";
 import { ISTSLogger, JSONObject } from '@nsshunt/stsutils'
 
-import { IIPCMessageProcessorIPCPayload } from './commonTypes'
+import { IIPCMessageProcessorIPCPayload, IServiceProcessContext } from './commonTypes'
 
 import { IPCMessageManager, IPCMessageManagerOptions } from './ipcMessageManager'
 import { Redis, RedisOptions } from "ioredis";
 
 import chalk from 'chalk';
+import { AggregateSteps } from "redis";
+import { ProcessOptions } from "./processoptions";
 
 const REQUEST_CHANNEL = '__STS__SVC_stsappframework_request'
 const RESPONSE_CHANNEL = '__STS__SVC_stsappframework_response'
@@ -18,6 +20,8 @@ export interface IRedisAdminManagerOptions {
     role: 'SERVER' | 'CLIENT'
     namespace: string
     groups: string[]
+    ignoreEvents?: string[]
+    processOptions?: ProcessOptions
 }
 
 export interface IClientRecord {
@@ -26,6 +30,7 @@ export interface IClientRecord {
     pingCount: number
     timeout: NodeJS.Timeout
     groups: string[]
+    serviceProcessContext?: IServiceProcessContext
 }
 
 export interface IEventPayload {
@@ -39,6 +44,12 @@ export interface IEventRecord {
     ctx?: any
 }
 
+export interface IPingData {
+    id: string
+    groups: string[]
+    serviceProcessContext?: IServiceProcessContext
+}
+
 export class RedisMessageHandler extends TinyEmitter {
     #ipcMessageManager: IPCMessageManager | null = null;
     #options: IRedisAdminManagerOptions;
@@ -80,26 +91,21 @@ export class RedisMessageHandler extends TinyEmitter {
         if (this.#options.role.localeCompare('CLIENT') === 0) {
             const ping = () => {
                 this.#pingTimeout = setTimeout(() => {
-                    let group = '';
-                    if (process.pid % 2 === 0) {
-                        group = 'even';
-                    } else {
-                        group = 'odd';
+                    const pingData: IPingData = {
+                        id: (this.#ipcMessageManager as IPCMessageManager).id,
+                        groups: this.#options.groups,
+                    }
+                    if (this.#options.processOptions) {
+                        pingData.serviceProcessContext = this.#options.processOptions.serviceProcessContext;
                     }
-                    //console.log(chalk.gray(`${process.pid}: emitting ping ...`))
-                    this.emit('ping', {
-                        id: this.#ipcMessageManager?.id,
-                        groups: [
-                            group
-                        ]
-                    }, (response: any) => { });
+                    this.emit('ping', pingData, (response: any) => { });
                     ping();
                 }, 1000).unref();
             }
             ping();
         } else {
-            this.on('ping', (pingData: JSONObject, callback: any) => {
-                const { id, groups } = pingData;
+            this.on('ping', (pingData: IPingData, callback: any) => {
+                const { id, groups, serviceProcessContext } = pingData;
                 if (this.#clients[id]) {
                     clearTimeout(this.#clients[id].timeout);
                     this.#clients[id].pingCount++;
@@ -107,6 +113,7 @@ export class RedisMessageHandler extends TinyEmitter {
                         delete this.#clients[id];
                     }, 2000);
                     this.#clients[id].groups = groups;
+                    this.#clients[id].serviceProcessContext = serviceProcessContext;
                 } else {
                     this.#clients[id] = {
                         id,
@@ -115,16 +122,13 @@ export class RedisMessageHandler extends TinyEmitter {
                         timeout: setTimeout(() => {
                             delete this.#clients[id];
                         }, 2000),
-                        groups
+                        groups,
+                        serviceProcessContext
                     }
                 }
-                //console.log(chalk.gray(`  ${process.pid}: processed ping ...`))
                 callback('ok');
             });
         }
-
-        console.log(chalk.yellow(`RedisMessageHandler:constructor(): [${JSON.stringify(this.#options.groups)}]`));
-
     }
 
     #LogInfo(message: any) {
@@ -140,10 +144,32 @@ export class RedisMessageHandler extends TinyEmitter {
         this.#ipcMessageManager?.ProcessMessage(message, { channel });
     }
 
+    get clients(): Record<string, IClientRecord> {
+        return this.#clients;
+    }
+
+    get groups(): string[] {
+        return this.#options.groups;
+    }
+    
+    AddGroup = (group: string) => {
+        const index = this.#options.groups.indexOf(group);
+        if (index === -1) {
+            this.#options.groups.push(group);
+        }
+    }
+
+    RemoveGroup = (group: string) => {
+        const removeIndex = this.#options.groups.indexOf(group);
+        if (removeIndex !== -1) {
+            this.#options.groups.splice(removeIndex, 1);
+        }
+    }
+
     SetupPrimary = () => {
         const ipcMessageManagerOptions: IPCMessageManagerOptions = {
             logger: this.#options.logger,
-            requestResponseMessageTimeout: 2000,
+            requestResponseMessageTimeout: 5000,
             namespace: this.#options.namespace,
             role: this.#options.role,
             messageSender: this.#messageSender,
@@ -179,48 +205,34 @@ export class RedisMessageHandler extends TinyEmitter {
         // Now check if we have all responses ...
         let allFound = false;
 
-        Object.keys(responses).forEach(r => {
-            if (responses[r].senderRole.localeCompare('CLIENT') === 0) {
+        for (const [responseId, response] of Object.entries(responses)) {
+            if (response.senderRole.localeCompare('CLIENT') === 0) {
                 allFound = true;
+                break;
             }
-        });
+        }
         if (allFound) {
             return allFound;
         }
 
-        console.log(chalk.grey(`${process.pid}:   -->> *** <<-- #ProcessResponseMessage`));
         let found = true;
 
         // Sender role here is SERVER
-
-        console.log(chalk.yellow(`${process.pid}:  Total Clients :-`));
-        Object.values(this.#clients).forEach(c => {
-            console.log(chalk.yellow(`${process.pid}:  ${c.id}    ${c.groups}`));
-        })
-
         let requestGroup = null;
-        console.log(chalk.blue(`${process.pid}:  Responses :-`));
         for (const [responseId, response] of Object.entries(responses)) {
-            console.log(chalk.blue(`${process.pid}:  client.id: [${responseId}]  response payload: [${JSON.stringify(response.responsePayload)}]`));
             if (response.requestPayload.args.length > 0 && response.requestPayload.args[0].group) {
                 requestGroup = response.requestPayload.args[0].group;
-                console.log(chalk.blue(`${process.pid}:  Group Request: [${requestGroup}]`));
                 break;
             }
         }
 
         if (requestGroup) {
-            console.log(chalk.blue(`${process.pid}:  Group Request`));
             const clientsInGroup = Object.values(this.#clients).filter(c => {
                 if (c.groups.indexOf(requestGroup) === -1) {
                     return false;
                 }
                 return true;
             });
-            console.log(chalk.blue(`${process.pid}:  Clients in group: [${requestGroup}] :-`));
-            clientsInGroup.forEach(c => {
-                console.log(chalk.blue(`${process.pid}:  ${c.id}`));
-            })
 
             // Now make sure that all clients are in the responses
             found = true;
@@ -229,15 +241,8 @@ export class RedisMessageHandler extends TinyEmitter {
                     found = false;
                 }
             })
-            console.log(chalk.blue(`${process.pid}:  found (group) = [${found}]`));
         } else {
-            console.log(chalk.blue(`${process.pid}:  Non-Group Request`));
-
             const clientsInGroup = Object.values(this.#clients)
-            console.log(chalk.blue(`${process.pid}:  Clients in group (global list): [${requestGroup}] :-`));
-            clientsInGroup.forEach(c => {
-                console.log(chalk.blue(`${process.pid}:  ${c.id}`));
-            })
 
             // Now make sure that all clients are in the responses
             found = true;
@@ -246,86 +251,9 @@ export class RedisMessageHandler extends TinyEmitter {
                     found = false;
                 }
             })
-            console.log(chalk.blue(`${process.pid}:  found (non-group) = [${found}]`));
         }
 
         return found;
-
-
-        /*
-
-
-        Object.values(this.#clients).map(c => {
-            if (found) {
-                // Check for group payloads
-
-                console.log(chalk.magenta(`${process.pid}:  clients (from ping data)`));
-                for (const [key, value] of Object.entries(this.#clients)) {
-                    console.log(chalk.magenta(`${process.pid}: ${key} = [${value.id}  ${value.groups}]`))
-                }
-                console.log(chalk.blue(`${process.pid}:  ${JSON.stringify(responses)}`));
-
-
-                if (responses[c.id]) {
-                    console.log(chalk.blue(`${process.pid}:  1`));
-                    if (responses[c.id].requestPayload) {
-                        console.log(chalk.blue(`${process.pid}:  2`));
-                        if (responses[c.id].requestPayload.args.length > 0) {
-                            console.log(chalk.blue(`${process.pid}:  3`));
-                            if (responses[c.id].requestPayload.args[0].group) {
-                                console.log(chalk.blue(`${process.pid}:  4`));
-                                console.log(chalk.magenta(`${process.pid}:requestPayload: [${JSON.stringify(responses[c.id].requestPayload.args[0].group )}]`))
-                                const requestGroup = responses[c.id].requestPayload.args[0].group;
-                                //const responseGroup = responses[c.id].responsePayload.args[0].group;
-
-                                console.log(chalk.magenta(`${process.pid}:  clients (from ping data)`));
-                                Object.values(this.#clients).forEach(c => {
-                                    console.log(chalk.magenta(`  ${c.groups}`))
-                                })
-                                console.log(chalk.magenta(`${process.pid}:`));
-
-                                console.log(chalk.magenta(`${process.pid}:  responses so far...`));
-
-                                for (const [key, value] of Object.entries(responses)) {
-                                    console.log(chalk.magenta(`${process.pid}:  client.id: [${key}]  response payload: [${JSON.stringify(value.responsePayload)}]`));
-                                }
-                                console.log(chalk.magenta(`${process.pid}:`));
-
-                                const clientsInGroup = Object.values(this.#clients).filter(c => {
-                                    const foundGroupIndex = c.groups.indexOf(requestGroup);
-                                    if (foundGroupIndex === -1) {
-                                        return false;
-                                    }
-                                    return true;
-                                });
-                                clientsInGroup.forEach(c => {
-                                    console.log(`${process.pid}:clientsInGroup: [${c.id}]   groups: [${c.groups}]`);
-                                    if (!responses[c.id]) {
-                                        console.log(`${process.pid}:  clientsInGroup - not found: [${c.id}]`);
-                                        found = false;
-                                    }
-                                });
-                                // Now check if all responses for completed group membership
-                            }
-                        }
-                    }
-                } else {
-                    if (!responses[c.id]) {
-                        found = false;
-                    }
-                }
-            }
-        });
-
-        console.log(chalk.grey(`${process.pid}:  ** Testing condition **`))
-        if (found === true) {
-            console.log(chalk.green(`${process.pid}:Found all messages - should return results`))
-            return true;
-        }
-        console.log(chalk.red(`${process.pid}:did not find all messages (yet) ...`))
-        return false;
-        */
-        return false;
     }
 
     #processPayload = (payload: IIPCMessageProcessorIPCPayload, options: any): Promise<JSONObject> => {
@@ -393,13 +321,30 @@ export class RedisMessageHandler extends TinyEmitter {
 
     override emit(event: string, ...args: any[]): this {
         (async () => {
-            const retVal = await this.#ipcMessageManager?.SendMessage({
-                __eventName: event,
-                args: args.slice(0, args.length-1)
-            } as IEventPayload);            
-            // Invoke the response callback
-            args[args.length-1](retVal);
+            try {
+                const retVal = await this.#ipcMessageManager?.SendMessage({
+                    __eventName: event,
+                    args: args.slice(0, args.length-1)
+                } as IEventPayload);            
+                // Invoke the response callback
+                args[args.length-1](retVal);
+            } catch (error) {
+                if (this.#options.ignoreEvents) {
+                    //console.log(chalk.red(`RedisMessageHandler:emit(): ignoreEvents: [${this.#options.ignoreEvents}]`))
+                    if (this.#options.ignoreEvents.indexOf((error as any).__eventName) !== -1) {
+                        return;
+                    }
+                }
+                this.#options.logger.error(chalk.red(`RedisMessageHandler:emit(): Error: [${JSON.stringify(error)}]`));
+            }
         })();
         return this;
     }
+
+    emitex = async(event: string, ...args: any[]): Promise<JSONObject> => {
+        return (this.#ipcMessageManager as IPCMessageManager).SendMessage({
+            __eventName: event,
+            args
+        } as IEventPayload);            
+    }
 }

package/src/testing/app.ts

@@ -108,7 +108,7 @@ const StartTestWorker = () => {
     const w1 = new IPCMessageProcessorWorker({
         logger: defaultLogger,
         namespace: 'test1',
-        requestResponseMessageTimeout: 2000,
+        requestResponseMessageTimeout: 5000,
         processPayload: async (payload) => {
             return {
                 msg1: `From WORKER: [${process.pid}]`,
@@ -121,7 +121,7 @@ const StartTestWorker = () => {
     const w2 = new IPCMessageProcessorWorker({
         logger: defaultLogger,
         namespace: 'test2',
-        requestResponseMessageTimeout: 2000,
+        requestResponseMessageTimeout: 5000,
         processPayload: async (payload) => {
             return {
                 msg2: `From WORKER: [${process.pid}]`,
@@ -134,7 +134,7 @@ const StartTestWorker = () => {
     const w3 = new IPCMessageProcessorWorker({
         logger: defaultLogger,
         namespace: 'zzz',
-        requestResponseMessageTimeout: 2000,
+        requestResponseMessageTimeout: 5000,
         processPayload: async (payload) => {
             switch (payload.requestPayload.cmd) {
             case 'cmd1' : return {
@@ -271,6 +271,15 @@ if (cluster.isPrimary) {
 
     LogSystemTelemetry();
 
+    const stsServiceControl: RedisMessageHandler = new RedisMessageHandler({
+        logger: defaultLogger,
+        role: 'SERVER',
+        redisUrl: goptions.imRedisMessageProcessorUrl,
+        namespace: 'stsServiceControl',
+        groups: [ ]
+    });
+    stsServiceControl.Start();
+
     setTimeout(() => {
         const p: Record<string, IPCMessageHandler> = { };
         /*
@@ -326,37 +335,55 @@ if (cluster.isPrimary) {
         });
         r1.Start();
 
-
+        const RunTest = async (eventName: string, emitobj: JSONObject) => {
+            const start = performance.now();
+            try {
+                const response = await r1.emitex(eventName, emitobj);
+                const duration = performance.now() - start;
+                console.log(chalk.cyan(`${process.pid}: Duration: ${duration} Test: [test1] Response(${chalk.bold(eventName)}): [${JSON.stringify(response)}]`));
+            } catch (error) {
+                const duration = performance.now() - start;
+                console.log(chalk.cyan(`${process.pid}: Duration: ${duration} Test: [test1] Response(${chalk.bold(eventName)}): Error: [${JSON.stringify(error)}]`));
+            }
+        }
 
         let i = 0;
         let group = '';
+        const maxIterations = 20;
         const xxx = () => {
             setTimeout(() => {
-
                 i++;
 
+                if (i > maxIterations) {
+                    return;
+                }
+
+                console.log(chalk.yellow(`Iteration: [${i}]`));
+
                 if (i % 2 === 0) {
                     group = 'even'
                 } else {
                     group = 'odd'
                 }
 
-                const emitobj = { group, i: i, a: 'a', b: 'b' };
-                r1.emit('fromprimaryredis', emitobj, (response: any) => {
-                    console.log(chalk.cyan(`${process.pid}: Response(fromprimaryredis): [${JSON.stringify(response)}]`));
-                });
-
-                /*
-                const globalemitobj = { i: i, a: 'a', b: 'b' };
-                r1.emit('globalmessage', globalemitobj, (response: any) => {
-                    console.log(chalk.cyan(`${process.pid}: Response(globalmessage): [${JSON.stringify(response)}]`));
-                });
-                */
-
-                //xxx();
-            }, 2000);
+                const promArray: Promise<void>[] = [ ];
+                const start = performance.now();
+                promArray.push(
+                    RunTest('fromprimaryredis', { group, i: i, a: 'a', b: 'b' }),
+                    RunTest('fromprimaryredis', { group: '2', i: i, a: 'a', b: 'b' }),
+                    RunTest('fromprimaryredis', { group: '4', i: i, a: 'a', b: 'b' }),
+                    RunTest('globalmessage', { i: i, a: 'a', b: 'b' })
+                );
+                (async () => {
+                    await Promise.all(promArray);
+                    const duration = performance.now() - start;
+                    console.log(chalk.green(`${process.pid}: Duration: ${duration} Test: [All Tests Run]`));
+                    console.log();
+                    xxx();
+                })();
+            }, 250);
         }
-        xxx();
+        setTimeout(() => xxx(), 1000);
 
 
 
@@ -392,7 +419,23 @@ if (cluster.isPrimary) {
 
         }, 1000);
         */
-    }, 1000);
+    }, 2000);
+
+
+    const ListClients = () => {
+        setTimeout(() => {
+            Object.values(stsServiceControl.clients).forEach(c => {
+                console.log(chalk.gray(`client id: [${c.id}]`));
+                console.log(chalk.gray(`client groups: [${c.groups}]`));
+                console.log(chalk.gray(`client pingCount: [${c.pingCount}]`));
+                console.log(chalk.gray(`client serviceProcessContext: [${JSON.stringify(c.serviceProcessContext)}]`));
+            });
+            ListClients();
+        }, 1000).unref();
+    }
+    ListClients();
+
+
 } else {
     new WorkerProcess(ServiceConfigOptions(true, cluster.isPrimary)).SetupServer();
     //StartTestWorker();
@@ -406,24 +449,29 @@ if (cluster.isPrimary) {
             group = 'odd'
         }
 
+        let workerId = '0';
+        if (cluster.worker) {
+            console.log(chalk.blue(`Worker: [${cluster.worker?.id}]`));
+            workerId = cluster.worker?.id.toString();
+        }
+
         const r1: RedisMessageHandler = new RedisMessageHandler({
             logger: defaultLogger,
             role: 'CLIENT',
             redisUrl: goptions.imRedisMessageProcessorUrl,
             namespace: 'mytestapp',
-            groups: [ group ]
+            groups: [ group, workerId ],
+            ignoreEvents: [ 'ping' ]
         });
         r1.Start();
 
         r1.on('fromprimaryredis', (arg1: JSONObject, callback: any) => {
-            console.log(chalk.greenBright(`   -->> ${process.pid}: fromprimaryredis.ON: [${JSON.stringify(arg1)}]`));
             callback( {
                 status: `PID: [${process.pid}]: response message from event = fromprimaryredis with args ${JSON.stringify(arg1)}`
             })
         });
 
         r1.on('globalmessage', (arg1: JSONObject, callback: any) => {
-            console.log(chalk.greenBright(`   -->> ${process.pid}: globalmessage.ON: [${JSON.stringify(arg1)}]`));
             callback( {
                 status: `PID: [${process.pid}]: response message from event = globalmessage with args ${JSON.stringify(arg1)}`
             })
@@ -471,5 +519,5 @@ if (cluster.isPrimary) {
             }
         }, 1000);
         */
-    }, 1000);
+    }, 2000);
 }

package/src/workerprocessbase.ts

@@ -27,11 +27,10 @@ import { GetFirstNetworkInterface } from './network'
 export class WorkerProcessBase extends ServerProcessBase implements IWorkerProcessBase
 {
     #inFlightMessage: IPCMessages = { }
-    #requestResponseMessageTimeout = 2000; //@@ config
+    #requestResponseMessageTimeout = 5000; //@@ config
     #redisMessageHandler: RedisMessageHandler | null = null;
     #redisMessageHandlerPing: number = 1000;
     #pingTimeout: NodeJS.Timeout | null = null;
-    #instanceId: string = uuidv4();
 
     constructor(options: ProcessOptions) {
         super(options);
@@ -84,7 +83,7 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
                         setTimeout(() => {
                             delete this.#inFlightMessage[message.id];
                         }, 0).unref();
-                        this.#LogDebugMessage(chalk.red(`Timeout has occurred after: [${this.#requestResponseMessageTimeout}]ms with message id: [${message.id}]. Details: [${JSON.stringify(this.#inFlightMessage[message.id].iPCMessagePayload)}]`));
+                        //this.#LogDebugMessage(chalk.red(`Timeout has occurred after: [${this.#requestResponseMessageTimeout}]ms with message id: [${message.id}]. Details: [${JSON.stringify(this.#inFlightMessage[message.id].iPCMessagePayload)}]`));
                         reject('Did not receive response form parent process.');
                     }, this.#requestResponseMessageTimeout) // max message timeout allowed
                 };
@@ -159,8 +158,6 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
     }
 
     GetSystemTelemetry = async () => {
-        
-
         // https://systeminformation.io/
         const valueObject = {
             system: '*',
@@ -186,7 +183,8 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
         const dockerContainerStats = await Promise.all(promArray);
     
         const sysInfo = {
-            instanceId: this.#instanceId,
+            serviceInstanceId: this.options.serviceInstanceId,
+            serviceProcessContext: this.options.serviceProcessContext,
             hostname,
             numCPUs,
             hostaddr,
@@ -266,25 +264,35 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
 
         await this.SetupSTSServer();
 
-        /*
         this.#redisMessageHandler = new RedisMessageHandler({
             logger: this.options.logger,
             role: 'CLIENT',
             redisUrl: goptions.imRedisMessageProcessorUrl,
             namespace: 'stsServiceControl',
-            groups: [ ]
+            groups: [ ],
+            ignoreEvents: [ 'ping' ],
+            processOptions: this.options
         });
         this.#redisMessageHandler.Start();
 
+        /*
         const ping = () => {
             this.#pingTimeout = setTimeout(() => {
                 const pingData = {
-                    instanceId: this.#instanceId
+                    group: 'stsServiceControlGroup',
+                    serviceInstanceId: this.options.serviceInstanceId,
+                    serviceName: this.options.serviceName,
+                    serviceVersion: this.options.serviceVersion,
+                    serviceProcessContext: this.options.serviceProcessContext
                 }
                 if (this.#redisMessageHandler) {
-                    this.#redisMessageHandler.emit('ping_ex', pingData, (response: any) => {
-                        console.log(chalk.cyan(`  ==>> ${process.pid}: Response(ping): [${JSON.stringify(response)}]`));
-                    });
+                    try {
+                        this.#redisMessageHandler.emit('ping_ex', pingData, (response: any) => {
+                            console.log(chalk.cyan(`  ==>> ${process.pid}: Response(ping): [${JSON.stringify(response)}]`));
+                        });
+                    } catch (error) {
+                        console.log(`************************************************`)
+                    }
                 }
                 ping();
             }, this.#redisMessageHandlerPing).unref();
@@ -292,6 +300,8 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
         ping();
         */
 
+
+
         //        this.#redisMessageHandler.on('GET_SYSTEM_TELEMETRY', async (getSystemTelemetryCommand: JSONObject, callback: any) => {
         //          callback({ instanceId: this.#instanceId, process: process.pid, systemTelemetry: getSystemTelemetryCommand });
         /*

package/types/index.d.ts

@@ -25,4 +25,5 @@ export * from './stsTransportLoggerWinston';
 export * from './ipcMessageProcessorPrimary';
 export * from './ipcMessageProcessorWorker';
 export * from './ipcMessageManager';
+export * from './redisMessageHandler';
 //# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,sBAAsB,CAAA;AACpC,cAAc,uBAAuB,CAAA;AACrC,cAAc,uBAAuB,CAAA;AACrC,cAAc,wBAAwB,CAAA;AACtC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,mCAAmC,CAAA;AACjD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,kCAAkC,CAAA;AAChD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,uBAAuB,CAAA;AACrC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,8BAA8B,CAAA;AAC5C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,qBAAqB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,sBAAsB,CAAA;AACpC,cAAc,uBAAuB,CAAA;AACrC,cAAc,uBAAuB,CAAA;AACrC,cAAc,wBAAwB,CAAA;AACtC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,mCAAmC,CAAA;AACjD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,kCAAkC,CAAA;AAChD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,uBAAuB,CAAA;AACrC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,8BAA8B,CAAA;AAC5C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA"}

package/types/ipcMessageManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ipcMessageManager.d.ts","sourceRoot":"","sources":["../src/ipcMessageManager.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAI1D,OAAO,EAAE,8BAA8B,EAAoC,MAAM,eAAe,CAAA;AAEhG,MAAM,WAAW,wBAAwB;IACrC,MAAM,EAAE,UAAU,CAAA;IAClB,6BAA6B,EAAE,MAAM,CAAA;IACrC,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAA;IACzB,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,aAAa,EAAE,CAAC,OAAO,EAAE,8BAA8B,EAAE,OAAO,EAAE,GAAG,KAAK,IAAI,CAAA;IAC9E,qBAAqB,EAAE,CAAC,OAAO,EAAE,8BAA8B,EAAE,OAAO,EAAE,GAAG,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA;IACrG,sBAAsB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,8BAA8B,CAAC,EAAE,OAAO,EAAE,GAAG,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACvH,oBAAoB,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,IAAI,CAAA;IAC5C,mBAAmB,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,IAAI,CAAA;CAC9C;AACD;;;;GAIG;AACH,qBAAa,iBAAiB;;gBAOd,OAAO,EAAE,wBAAwB;IAU7C,IAAI,EAAE,WAEL;IAGD,yBAAyB,CAAC,GAAG,EAAE,GAAG;IAIlC,WAAW,YAAa,UAAU,YAAY,GAAG,KAAG,OAAO,CAAC,UAAU,CAAC,CAUtE;IAqFD,KAAK,aAAc,GAAG,UAGrB;IAED,IAAI,aAAc,GAAG,UAUpB;IAGD,cAAc,QAAe,GAAG,WAAW,GAAG,mBAoC7C;CACJ"}
+{"version":3,"file":"ipcMessageManager.d.ts","sourceRoot":"","sources":["../src/ipcMessageManager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAI1D,OAAO,EAAE,8BAA8B,EAAoC,MAAM,eAAe,CAAA;AAEhG,MAAM,WAAW,wBAAwB;IACrC,MAAM,EAAE,UAAU,CAAA;IAClB,6BAA6B,EAAE,MAAM,CAAA;IACrC,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAA;IACzB,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,aAAa,EAAE,CAAC,OAAO,EAAE,8BAA8B,EAAE,OAAO,EAAE,GAAG,KAAK,IAAI,CAAA;IAC9E,qBAAqB,EAAE,CAAC,OAAO,EAAE,8BAA8B,EAAE,OAAO,EAAE,GAAG,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA;IACrG,sBAAsB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,8BAA8B,CAAC,EAAE,OAAO,EAAE,GAAG,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACvH,oBAAoB,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,IAAI,CAAA;IAC5C,mBAAmB,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,IAAI,CAAA;CAC9C;AACD;;;;GAIG;AACH,qBAAa,iBAAiB;;gBAOd,OAAO,EAAE,wBAAwB;IAU7C,IAAI,EAAE,WAEL;IAGD,yBAAyB,CAAC,GAAG,EAAE,GAAG;IAIlC,WAAW,YAAa,UAAU,YAAY,GAAG,KAAG,OAAO,CAAC,UAAU,CAAC,CAUtE;IAwED,KAAK,aAAc,GAAG,UAGrB;IAED,IAAI,aAAc,GAAG,UAUpB;IAGD,cAAc,QAAe,GAAG,WAAW,GAAG,mBAuB7C;CACJ"}

package/types/masterprocessbase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"masterprocessbase.d.ts","sourceRoot":"","sources":["../src/masterprocessbase.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,cAAc,EAAiB,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AACjE,OAAO,EAAE,iBAAiB,EAAqB,MAAM,eAAe,CAAA;AAKpE,qBAAa,iBAAkB,SAAQ,WAAY,YAAW,kBAAkB;;gBAiBhE,OAAO,EAAE,cAAc;IAmB1B,0BAA0B,IAAI,IAAI;IAQlC,wBAAwB,IAAI,qBAAqB;IAS1D;;;OAGA;IAEA,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG;IAmI7C,WAAW,sBAKV;IAgCD,UAAU,OAAQ,MAAM,UAAU,MAAM,CAAC,OAAO,uBAAuB,GAAG,eAAe,OAAO,gBAAgB,OAAO,KAAG,OAAO,CA6BhI;IAED,WAAW,WAAY,MAAM,CAAC,OAAO,YAAY,OAAO,KAAG,IAAI,CAkB9D;IAUD,UAAU,QAAO,IAAI,CAIpB;IAED,UAAU,QAAO,IAAI,CAIpB;IAGD,SAAS,YAAa,GAAG,KAAG,MAAM,CAOjC;IAEK,iBAAiB,CAAC,iBAAiB,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAoGzF,aAAa,IAAI,IAAI;IASrB,IAAa,YAAY,IAAI,OAAO,CAEnC;IAED,aAAa,sBAuKZ;IAED,sBAAsB,YAAa,GAAG,QAAQ,GAAG,UAahD;CACJ"}
+{"version":3,"file":"masterprocessbase.d.ts","sourceRoot":"","sources":["../src/masterprocessbase.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,cAAc,EAAiB,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AACjE,OAAO,EAAE,iBAAiB,EAAqB,MAAM,eAAe,CAAA;AAOpE,qBAAa,iBAAkB,SAAQ,WAAY,YAAW,kBAAkB;;gBAiBhE,OAAO,EAAE,cAAc;IAmB1B,0BAA0B,IAAI,IAAI;IAQlC,wBAAwB,IAAI,qBAAqB;IAS1D;;;OAGA;IAEA,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG;IAmI7C,WAAW,sBAKV;IAgCD,UAAU,OAAQ,MAAM,UAAU,MAAM,CAAC,OAAO,uBAAuB,GAAG,eAAe,OAAO,gBAAgB,OAAO,KAAG,OAAO,CA6BhI;IAED,WAAW,WAAY,MAAM,CAAC,OAAO,YAAY,OAAO,KAAG,IAAI,CAkB9D;IAUD,UAAU,QAAO,IAAI,CAIpB;IAED,UAAU,QAAO,IAAI,CAIpB;IAGD,SAAS,YAAa,GAAG,KAAG,MAAM,CAOjC;IAEK,iBAAiB,CAAC,iBAAiB,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAoGzF,aAAa,IAAI,IAAI;IASrB,IAAa,YAAY,IAAI,OAAO,CAEnC;IAED,aAAa,sBAuLZ;IAED,sBAAsB,YAAa,GAAG,QAAQ,GAAG,UAahD;CACJ"}