SimpleMessager for worker

EvHandler

let eventEmitter = require("events").EventEmitter;

class EvHandler extends eventEmitter {
    constructor(process) {
        super();
        let listener = this.onMessage.bind(this);
        process.on("message", listener);
        let clear = () => {
            this.cbs = null;
            this.removeAllListeners();
            if (this.process) {
                this.process.removeListener("message", listener);
                this.process = null;
            }
        };
        process.once("exit", clear);
        // process.once("close", clear);
        // process.once("disconnect", clear);
        this.process = process;
        this.cbs = new Map();
    }

    onMessage({ type, op, data, id, cb }, sendHandle) {
        let callback;
        if (id) {
            callback = (...arg) => {
                if (arg[0] instanceof Error) {
                    arg[0] = {
                        message: arg[0].message,
                        stack: arg[0].stack,
                        name: arg[0].name,
                        isError: true,
                    }
                }
                this.process.send({ cb: id, data: arg });
            }
        }
        if (cb) {
            let fn = this.cbs.get(cb);
            this.cbs.delete(cb);
            let err = data[0];
            if (err && err.isError) {
                err.inspect = err.toString = function () {
                    return this.stack;
                };
                //     // let e = data[0] = new Error();
                //     // e.name = err.name;
                //     // e.stack = err.stack;
                //     // e.message = err.message;
            }
            fn && fn.apply(null, data);
        } else {
            this.emit(type, { type, op, data }, callback);
        }
    }

    send(type, op, data, callback) {
        let param = { type, op, data };
        if (callback) {
            param.id = Math.random() + "" + Date.now();
            this.cbs.set(param.id, callback);
        }
        this.process.send(param);
    }
}

module.exports = EvHandler;

Messager.js

var EventEmitter = require('events');

export default class Messager extends EventEmitter {
    constructor(worker) {
        super();
        this.worker = worker;
        worker.addEventListener('message', this._onMessage.bind(this), false);
        this.callbacks = new Map();
    }

    _onMessage(ev) {
        var data = JSON.parse(ev.data);
        var token = data.token;
        var type = data.type;
        if (type === 'callback' && token) {
            var cb = this.callbacks.get(token);
            this.callbacks.delete(token);
            if (cb) {
                cb(data.data);
            }
        }
        //console.log(this);
        this.emit(type, data.data, token && ((data)=> {
                this._sendMessage('callback', data, token);
            }));
    }

    _sendMessage(type, data, callback) {
        var token;
        if (typeof callback === "function") {
            token = callback ? Date.now() + '_' + Math.random() : false;
            this.callbacks.set(token, callback);
        } else {
            token = callback;
        }
        //console.log(this);
        this.worker.postMessage(JSON.stringify({
            type: type,
            data: data || null,
            token: token || false
        }));
    }

    sendMessage(type, data, callback) {
        this._sendMessage(type, data, callback);
    }
}